1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Pell.Solution₁.eq_one_of_x_eq_one
File: Mathlib/NumberTheory/Pell.lean

tactic: have prop := a.prop_y
state_before: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
⊢ a = 1
state_after: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : d * a.y ^ 2 = a.x ^ 2 - 1
⊢ a = 1

tactic: rw [ha, one_pow, sub_self, mul_eq_zero, or_iff_right h₀, sq_eq_zero_iff] at prop
state_before: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : d * a.y ^ 2 = a.x ^ 2 - 1
⊢ a = 1
state_after: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : a.y = 0
⊢ a = 1

tactic: exact ext ha prop
state_before: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : a.y = 0
⊢ a = 1
state_after: no goals
Theorem: Profinite.NobelingProof.fin_comap_jointlySurjective
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: obtain ⟨J, g, h⟩ := @Profinite.exists_locallyConstant (Finset I)ᵒᵖ _ _ _
  (spanCone hC.isCompact) ℤ
  (spanCone_isLimit hC.isCompact) f
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
f : LocallyConstant ↑C ℤ
⊢ ∃ s g, f = LocallyConstant.comap { toFun := ProjRestrict C fun x => x ∈ s, continuous_toFun := ⋯ } g
state_after: case intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
f : LocallyConstant ↑C ℤ
J : (Finset I)ᵒᵖ
g : LocallyConstant ↑((spanFunctor ⋯).obj J).toCompHaus.toTop ℤ
h : f = LocallyConstant.comap ((spanCone ⋯).π.app J) g
⊢ ∃ s g, f = LocallyConstant.comap { toFun := ProjRestrict C fun x => x ∈ s, continuous_toFun := ⋯ } g

tactic: exact ⟨(Opposite.unop J), g, h⟩
state_before: case intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
hC : IsClosed C
f : LocallyConstant ↑C ℤ
J : (Finset I)ᵒᵖ
g : LocallyConstant ↑((spanFunctor ⋯).obj J).toCompHaus.toTop ℤ
h : f = LocallyConstant.comap ((spanCone ⋯).π.app J) g
⊢ ∃ s g, f = LocallyConstant.comap { toFun := ProjRestrict C fun x => x ∈ s, continuous_toFun := ⋯ } g
state_after: no goals
Theorem: Function.Periodic.tendsto_atTop_intervalIntegral_of_pos
File: Mathlib/MeasureTheory/Integral/Periodic.lean

tactic: apply tendsto_atTop_mono (hg.sInf_add_zsmul_le_integral_of_pos h_int hT)
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun t => ∫ (x : ℝ) in 0 ..t, g x) atTop atTop
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun n => sInf ((fun t => ∫ (x : ℝ) in 0 ..t, g x) '' Icc 0 T) + ⌊n / T⌋ • ∫ (x : ℝ) in 0 ..T, g x) atTop
    atTop

tactic: apply atTop.tendsto_atTop_add_const_left (sInf <| (fun t => ∫ x in (0)..t, g x) '' Icc 0 T)
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun n => sInf ((fun t => ∫ (x : ℝ) in 0 ..t, g x) '' Icc 0 T) + ⌊n / T⌋ • ∫ (x : ℝ) in 0 ..T, g x) atTop
    atTop
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun x => ⌊x / T⌋ • ∫ (x : ℝ) in 0 ..T, g x) atTop atTop

tactic: apply Tendsto.atTop_zsmul_const h₀
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun x => ⌊x / T⌋ • ∫ (x : ℝ) in 0 ..T, g x) atTop atTop
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun x => ⌊x / T⌋) atTop atTop

tactic: exact tendsto_floor_atTop.comp (tendsto_id.atTop_mul_const (inv_pos.mpr hT))
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → E
T : ℝ
g : ℝ → ℝ
hg : Periodic g T
h_int : ∀ (t₁ t₂ : ℝ), IntervalIntegrable g volume t₁ t₂
h₀ : 0 < ∫ (x : ℝ) in 0 ..T, g x
hT : 0 < T
⊢ Tendsto (fun x => ⌊x / T⌋) atTop atTop
state_after: no goals
Theorem: HomologicalComplex₂.ι_D₂
File: Mathlib/Algebra/Homology/TotalComplex.lean

tactic: apply totalAux.ιMapObj_D₂
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' : I₁₂
i₁ : I₁
i₂ : I₂
h : c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂
⊢ K.ιTotal c₁₂ i₁ i₂ i₁₂ h ≫ K.D₂ c₁₂ i₁₂ i₁₂' = K.d₂ c₁₂ i₁ i₂ i₁₂'
state_after: no goals
Theorem: CategoryTheory.CommSq.vert_inv
File: Mathlib/CategoryTheory/CommSq.lean

tactic: rw [Iso.comp_inv_eq, Category.assoc, Iso.eq_inv_comp, p.w]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
W X Y Z : C
f : W ⟶ X
g✝ : W ⟶ Y
h✝ : X ⟶ Z
i : Y ⟶ Z
g : W ≅ Y
h : X ≅ Z
p : CommSq f g.hom h.hom i
⊢ i ≫ h.inv = g.inv ≫ f
state_after: no goals
Theorem: Substring.ValidFor.next_stop
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [Substring.next, Pos.add_eq]
state_before: l m r : List Char
⊢ { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
          stopPos := { byteIdx := utf8Len l + utf8Len m } }.next
      { byteIdx := utf8Len m } =
    { byteIdx := utf8Len m }
state_after: no goals
Theorem: LinearMap.BilinForm.isSymm_iff_flip
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

tactic: exact eq_comm
state_before: R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁹ : CommRing R₁
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁶ : Field K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
M' : Type u_7
M'' : Type u_8
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M''
inst✝¹ : Module R M'
inst✝ : Module R M''
B : BilinForm R M
B₁ : BilinForm R₁ M₁
R₂ : ?m.77414
x✝¹ x✝ : M
⊢ (RingHom.id R) ((B x✝¹) x✝) = (B x✝) x✝¹ ↔ ((flipHom B) x✝¹) x✝ = (B x✝¹) x✝
state_after: no goals
Theorem: convexJoin_segment_singleton
File: Mathlib/Analysis/Convex/Join.lean

tactic: rw [← pair_eq_singleton, ← convexJoin_segments, segment_same, pair_eq_singleton]
state_before: ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t u : Set E
x y a b c : E
⊢ convexJoin 𝕜 (segment 𝕜 a b) {c} = (convexHull 𝕜) {a, b, c}
state_after: no goals
Theorem: supClosed_range
File: Mathlib/Order/SupClosed.lean

tactic: simpa using supClosed_univ.image f
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : SemilatticeSup α
inst✝² : SemilatticeSup β
ι : Sort u_4
S : Set (Set α)
f✝ : ι → Set α
s t : Set α
a : α
inst✝¹ : FunLike F α β
inst✝ : SupHomClass F α β
f : F
⊢ SupClosed (range ⇑f)
state_after: no goals
Theorem: TopCat.pullback_fst_range
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: ext x
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
⊢ Set.range ⇑pullback.fst = {x | ∃ y, f x = g y}
state_after: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑pullback.fst ↔ x ∈ {x | ∃ y, f x = g y}

tactic: constructor
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑pullback.fst ↔ x ∈ {x | ∃ y, f x = g y}
state_after: case h.mp
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑pullback.fst → x ∈ {x | ∃ y, f x = g y}

case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ {x | ∃ y, f x = g y} → x ∈ Set.range ⇑pullback.fst

tactic: rintro ⟨(y : (forget TopCat).obj _), rfl⟩
state_before: case h.mp
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑pullback.fst → x ∈ {x | ∃ y, f x = g y}
state_after: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
y : (forget TopCat).obj (pullback f g)
⊢ pullback.fst y ∈ {x | ∃ y, f x = g y}

tactic: use (pullback.snd : pullback f g ⟶ _) y
state_before: case h.mp.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
y : (forget TopCat).obj (pullback f g)
⊢ pullback.fst y ∈ {x | ∃ y, f x = g y}
state_after: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
y : (forget TopCat).obj (pullback f g)
⊢ f (pullback.fst y) = g (pullback.snd y)

tactic: exact ConcreteCategory.congr_hom pullback.condition y
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
y : (forget TopCat).obj (pullback f g)
⊢ f (pullback.fst y) = g (pullback.snd y)
state_after: no goals

tactic: rintro ⟨y, eq⟩
state_before: case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ {x | ∃ y, f x = g y} → x ∈ Set.range ⇑pullback.fst
state_after: case h.mpr.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
y : ↑Y
eq : f x = g y
⊢ x ∈ Set.range ⇑pullback.fst

tactic: use (TopCat.pullbackIsoProdSubtype f g).inv ⟨⟨x, y⟩, eq⟩
state_before: case h.mpr.intro
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
y : ↑Y
eq : f x = g y
⊢ x ∈ Set.range ⇑pullback.fst
state_after: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
y : ↑Y
eq : f x = g y
⊢ pullback.fst ((pullbackIsoProdSubtype f g).inv ⟨(x, y), eq⟩) = x

tactic: rw [pullbackIsoProdSubtype_inv_fst_apply]
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
y : ↑Y
eq : f x = g y
⊢ pullback.fst ((pullbackIsoProdSubtype f g).inv ⟨(x, y), eq⟩) = x
state_after: no goals
Theorem: Real.cos_pi_div_sixteen
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: trans cos (π / 2 ^ 4)
state_before: x : ℝ
⊢ cos (π / 16) = √(2 + √(2 + √2)) / 2
state_after: x : ℝ
⊢ cos (π / 16) = cos (π / 2 ^ 4)

x : ℝ
⊢ cos (π / 2 ^ 4) = √(2 + √(2 + √2)) / 2

tactic: congr
state_before: x : ℝ
⊢ cos (π / 16) = cos (π / 2 ^ 4)
state_after: case e_x.e_a
x : ℝ
⊢ 16 = 2 ^ 4

tactic: norm_num
state_before: case e_x.e_a
x : ℝ
⊢ 16 = 2 ^ 4
state_after: no goals

tactic: simp
state_before: x : ℝ
⊢ cos (π / 2 ^ 4) = √(2 + √(2 + √2)) / 2
state_after: no goals
Theorem: ENNReal.sub_mul
File: Mathlib/Data/ENNReal/Operations.lean

tactic: rcases le_or_lt a b with hab | hab
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
⊢ (a - b) * c = a * c - b * c
state_after: case inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : a ≤ b
⊢ (a - b) * c = a * c - b * c

case inr
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : b < a
⊢ (a - b) * c = a * c - b * c

tactic: rcases eq_or_lt_of_le (zero_le b) with (rfl | hb)
state_before: case inr
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : b < a
⊢ (a - b) * c = a * c - b * c
state_after: case inr.inl
a c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < 0 → 0 < a → c ≠ ⊤
hab : 0 < a
⊢ (a - 0) * c = a * c - 0 * c

case inr.inr
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : b < a
hb : 0 < b
⊢ (a - b) * c = a * c - b * c

tactic: exact (cancel_of_ne <| mul_ne_top hab.ne_top (h hb hab)).tsub_mul
state_before: case inr.inr
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : b < a
hb : 0 < b
⊢ (a - b) * c = a * c - b * c
state_after: no goals

tactic: simp [hab, mul_right_mono hab]
state_before: case inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ ⊤
hab : a ≤ b
⊢ (a - b) * c = a * c - b * c
state_after: no goals

tactic: simp
state_before: case inr.inl
a c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < 0 → 0 < a → c ≠ ⊤
hab : 0 < a
⊢ (a - 0) * c = a * c - 0 * c
state_after: no goals
Theorem: Odd.pow
File: Mathlib/Algebra/Ring/Parity.lean

tactic: rw [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
ha : Odd a
⊢ Odd (a ^ 0)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
ha : Odd a
⊢ Odd 1

tactic: exact odd_one
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
ha : Odd a
⊢ Odd 1
state_after: no goals

tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n✝ : ℕ
ha : Odd a
n : ℕ
⊢ Odd (a ^ (n + 1))
state_after: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n✝ : ℕ
ha : Odd a
n : ℕ
⊢ Odd (a ^ n * a)

tactic: exact ha.pow.mul ha
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n✝ : ℕ
ha : Odd a
n : ℕ
⊢ Odd (a ^ n * a)
state_after: no goals
Theorem: Matrix.Fin.conjTranspose_circulant
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective, eq_iff_true_of_subsingleton]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
R : Type u_5
inst✝ : Star α
⊢ ∀ (v : Fin 0 → α), (circulant v)ᴴ = circulant (star fun i => v (-i))
state_after: no goals
Theorem: Complex.sin_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← ofReal_sin, Real.sin_pi]
state_before: ⊢ sin ↑π = 0
state_after: ⊢ ↑0 = 0

tactic: simp
state_before: ⊢ ↑0 = 0
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.homMk₅_app_five
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: valid
state_before: C : Type u_1
inst✝ : Category.{?u.433635, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 5
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ⟶ g.obj' 4 ⋯
app₅ : f.obj' 5 ⋯ ⟶ g.obj' 5 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃ = app₂ ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄ = app₃ ≫ g.map' 3 4 ⋯ ⋯
w₄ : f.map' 4 5 ⋯ ⋯ ≫ app₅ = app₄ ≫ g.map' 4 5 ⋯ ⋯
⊢ 5 < 5 + 1
state_after: no goals
Theorem: AddChar.sum_eq_zero_of_ne_one
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

tactic: rcases ne_one_iff.1 hψ with ⟨b, hb⟩
state_before: R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
⊢ ∑ a : R, ψ a = 0
state_after: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
⊢ ∑ a : R, ψ a = 0

tactic: have h₁ : ∑ a : R, ψ (b + a) = ∑ a : R, ψ a :=
  Fintype.sum_bijective _ (AddGroup.addLeft_bijective b) _ _ fun x => rfl
state_before: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
⊢ ∑ a : R, ψ a = 0
state_after: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ∑ a : R, ψ (b + a) = ∑ a : R, ψ a
⊢ ∑ a : R, ψ a = 0

tactic: simp_rw [map_add_eq_mul] at h₁
state_before: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ∑ a : R, ψ (b + a) = ∑ a : R, ψ a
⊢ ∑ a : R, ψ a = 0
state_after: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ∑ x : R, ψ b * ψ x = ∑ a : R, ψ a
⊢ ∑ a : R, ψ a = 0

tactic: have h₂ : ∑ a : R, ψ a = Finset.univ.sum ↑ψ := rfl
state_before: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ∑ x : R, ψ b * ψ x = ∑ a : R, ψ a
⊢ ∑ a : R, ψ a = 0
state_after: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ∑ x : R, ψ b * ψ x = ∑ a : R, ψ a
h₂ : ∑ a : R, ψ a = Finset.univ.sum ⇑ψ
⊢ ∑ a : R, ψ a = 0

tactic: rw [← Finset.mul_sum, h₂] at h₁
state_before: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ∑ x : R, ψ b * ψ x = ∑ a : R, ψ a
h₂ : ∑ a : R, ψ a = Finset.univ.sum ⇑ψ
⊢ ∑ a : R, ψ a = 0
state_after: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ψ b * Finset.univ.sum ⇑ψ = Finset.univ.sum ⇑ψ
h₂ : ∑ a : R, ψ a = Finset.univ.sum ⇑ψ
⊢ ∑ a : R, ψ a = 0

tactic: exact eq_zero_of_mul_eq_self_left hb h₁
state_before: case intro
R : Type u_1
inst✝³ : AddGroup R
inst✝² : Fintype R
R' : Type u_2
inst✝¹ : CommRing R'
inst✝ : IsDomain R'
ψ : AddChar R R'
hψ : ψ ≠ 1
b : R
hb : ψ b ≠ 1
h₁ : ψ b * Finset.univ.sum ⇑ψ = Finset.univ.sum ⇑ψ
h₂ : ∑ a : R, ψ a = Finset.univ.sum ⇑ψ
⊢ ∑ a : R, ψ a = 0
state_after: no goals
Theorem: Multiset.noncommProd_map
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: induction s using Quotient.inductionOn
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
s : Multiset α
comm : {x | x ∈ s}.Pairwise Commute
f : F
⊢ f (s.noncommProd comm) = (map (⇑f) s).noncommProd ⋯
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
⊢ f (noncommProd ⟦a✝⟧ comm) = (map ⇑f ⟦a✝⟧).noncommProd ⋯

tactic: simpa using map_list_prod f _
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
⊢ f (noncommProd ⟦a✝⟧ comm) = (map ⇑f ⟦a✝⟧).noncommProd ⋯
state_after: no goals
Theorem: Asymptotics.isLittleO_one_left_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [norm_one, zero_le_one]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁵ : Norm E
inst✝¹⁴ : Norm F
inst✝¹³ : Norm G
inst✝¹² : SeminormedAddCommGroup E'
inst✝¹¹ : SeminormedAddCommGroup F'
inst✝¹⁰ : SeminormedAddCommGroup G'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F''
inst✝⁷ : NormedAddCommGroup G''
inst✝⁶ : SeminormedRing R
inst✝⁵ : SeminormedAddGroup E'''
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedDivisionRing 𝕜
inst✝² : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : One F
inst✝ : NormOneClass F
_x : α
⊢ 0 ≤ ‖1‖
state_after: no goals

tactic: simp only [norm_one, mul_one, true_imp_iff, mem_Ici]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹⁵ : Norm E
inst✝¹⁴ : Norm F
inst✝¹³ : Norm G
inst✝¹² : SeminormedAddCommGroup E'
inst✝¹¹ : SeminormedAddCommGroup F'
inst✝¹⁰ : SeminormedAddCommGroup G'
inst✝⁹ : NormedAddCommGroup E''
inst✝⁸ : NormedAddCommGroup F''
inst✝⁷ : NormedAddCommGroup G''
inst✝⁶ : SeminormedRing R
inst✝⁵ : SeminormedAddGroup E'''
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedDivisionRing 𝕜
inst✝² : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : One F
inst✝ : NormOneClass F
⊢ (∀ (n : ℕ), ∀ᶠ (x : α) in l, ↑n * ‖1‖ ≤ ‖f x‖) ↔ ∀ (n : ℕ), True → ∀ᶠ (x : α) in l, ‖f x‖ ∈ Ici ↑n
state_after: no goals
Theorem: CategoryTheory.counit_obj_eq_map_counit
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: rw [← cancel_epi (j.map ((coreflectorAdjunction j).unit.app ((coreflector j).obj X))),
  ← j.map_comp]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
j : C ⥤ D
inst✝ : Coreflective j
X : D
⊢ (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
    j.map ((coreflector j).map ((coreflectorAdjunction j).counit.app X))
state_after: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
j : C ⥤ D
inst✝ : Coreflective j
X : D
⊢ j.map ((coreflectorAdjunction j).unit.app ((coreflector j).obj X)) ≫
      (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
    j.map
      ((coreflectorAdjunction j).unit.app ((coreflector j).obj X) ≫
        (coreflector j).map ((coreflectorAdjunction j).counit.app X))

tactic: simp
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
j : C ⥤ D
inst✝ : Coreflective j
X : D
⊢ j.map ((coreflectorAdjunction j).unit.app ((coreflector j).obj X)) ≫
      (coreflectorAdjunction j).counit.app (j.obj ((coreflector j).obj X)) =
    j.map
      ((coreflectorAdjunction j).unit.app ((coreflector j).obj X) ≫
        (coreflector j).map ((coreflectorAdjunction j).counit.app X))
state_after: no goals
Theorem: Class.mem_of_mem_sInter
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: obtain ⟨w, rfl, hw⟩ := hy
state_before: x y z : Class
hy : y ∈ ⋂₀ x
hz : z ∈ x
⊢ y ∈ z
state_after: case intro.intro
x z : Class
hz : z ∈ x
w : ZFSet
hw : (⋂₀ x) w
⊢ ↑w ∈ z

tactic: exact coe_mem.2 (hw z hz)
state_before: case intro.intro
x z : Class
hz : z ∈ x
w : ZFSet
hw : (⋂₀ x) w
⊢ ↑w ∈ z
state_after: no goals