1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Sieve.ofArrows_mk
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ Z : C
f✝ : Y✝ ⟶ X✝
S R : Sieve X✝
I : Type u_1
X : C
Y : I → C
f : (i : I) → Y i ⟶ X
i : I
⊢ 𝟙 (Y i) ≫ f i = f i
state_after: no goals
Theorem: Set.range_list_get
File: Mathlib/Data/Set/List.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
l : List α
⊢ range l.get = {x | x ∈ l}
state_after: case h
α : Type u_1
β : Type u_2
l : List α
x : α
⊢ x ∈ range l.get ↔ x ∈ {x | x ∈ l}

tactic: rw [mem_setOf_eq, mem_iff_get, mem_range]
state_before: case h
α : Type u_1
β : Type u_2
l : List α
x : α
⊢ x ∈ range l.get ↔ x ∈ {x | x ∈ l}
state_after: no goals
Theorem: Finsupp.unique_single_eq_iff
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [unique_ext_iff, Unique.eq_default a, Unique.eq_default a', single_eq_same, single_eq_same]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
a a' : α
b : M
inst✝ : Unique α
b' : M
⊢ single a b = single a' b' ↔ b = b'
state_after: no goals
Theorem: skyscraperPresheaf_isSheaf
File: Mathlib/Topology/Sheaves/Skyscraper.lean

tactic: dsimp [skyscraperPresheaf]
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ IsTerminal ((skyscraperPresheaf PUnit.unit A).obj { unop := ⊥ })
state_after: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ IsTerminal (if PUnit.unit ∈ ⊥ then A else ⊤_ C)

tactic: rw [if_neg]
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ IsTerminal (if PUnit.unit ∈ ⊥ then A else ⊤_ C)
state_after: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ IsTerminal (⊤_ C)

case hnc
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ PUnit.unit ∉ ⊥

tactic: exact terminalIsTerminal
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ IsTerminal (⊤_ C)
state_after: no goals

tactic: exact Set.not_mem_empty PUnit.unit.{u+1}
state_before: case hnc
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
⊢ PUnit.unit ∉ ⊥
state_after: no goals
Theorem: Int.div_dvd_iff_dvd_mul
File: Mathlib/Data/Int/Defs.lean

tactic: have := Int.dvd_trans (Int.dvd_mul_left _ _) (Int.mul_dvd_mul_left d h)
state_before: a b c d✝ m n : ℤ
h : b ∣ a
hb : b ≠ 0
d : ℤ
⊢ c = a / b * d ↔ b * c = a * d
state_after: a b c d✝ m n : ℤ
h : b ∣ a
hb : b ≠ 0
d : ℤ
this : b ∣ d * a
⊢ c = a / b * d ↔ b * c = a * d

tactic: rw [eq_comm, Int.mul_comm, ← Int.mul_ediv_assoc d h, Int.ediv_eq_iff_eq_mul_right hb this,
  Int.mul_comm, eq_comm]
state_before: a b c d✝ m n : ℤ
h : b ∣ a
hb : b ≠ 0
d : ℤ
this : b ∣ d * a
⊢ c = a / b * d ↔ b * c = a * d
state_after: no goals
Theorem: SimpleGraph.ComponentCompl.pairwise_disjoint
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: rintro C D ne
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
⊢ Pairwise fun C D => Disjoint ↑C ↑D
state_after: V : Type u
G : SimpleGraph V
K L L' M : Set V
C D : G.ComponentCompl K
ne : C ≠ D
⊢ Disjoint ↑C ↑D

tactic: rw [Set.disjoint_iff]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C D : G.ComponentCompl K
ne : C ≠ D
⊢ Disjoint ↑C ↑D
state_after: V : Type u
G : SimpleGraph V
K L L' M : Set V
C D : G.ComponentCompl K
ne : C ≠ D
⊢ ↑C ∩ ↑D ⊆ ∅

tactic: exact fun u ⟨uC, uD⟩ => ne (uC.choose_spec.symm.trans uD.choose_spec)
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C D : G.ComponentCompl K
ne : C ≠ D
⊢ ↑C ∩ ↑D ⊆ ∅
state_after: no goals
Theorem: strongConvexOn_iff_convex
File: Mathlib/Analysis/Convex/Strong.lean

tactic: refine and_congr_right fun _ ↦ forall₄_congr fun x _ y _ ↦ forall₅_congr fun a b ha hb hab ↦ ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f : E → ℝ
⊢ StrongConvexOn s m f ↔ ConvexOn ℝ s fun x => f x - m / 2 * ‖x‖ ^ 2
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝³ y✝ : E
f : E → ℝ
x✝² : Convex ℝ s
x : E
x✝¹ : x ∈ s
y : E
x✝ : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f (a • x + b • y) ≤ a • f x + b • f y - a * b * (fun r => m / 2 * r ^ 2) ‖x - y‖ ↔
    (fun x => f x - m / 2 * ‖x‖ ^ 2) (a • x + b • y) ≤
      a • (fun x => f x - m / 2 * ‖x‖ ^ 2) x + b • (fun x => f x - m / 2 * ‖x‖ ^ 2) y

tactic: simp_rw [sub_le_iff_le_add, smul_eq_mul, aux_sub ha hb hab, mul_assoc, mul_left_comm]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝³ y✝ : E
f : E → ℝ
x✝² : Convex ℝ s
x : E
x✝¹ : x ∈ s
y : E
x✝ : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f (a • x + b • y) ≤ a • f x + b • f y - a * b * (fun r => m / 2 * r ^ 2) ‖x - y‖ ↔
    (fun x => f x - m / 2 * ‖x‖ ^ 2) (a • x + b • y) ≤
      a • (fun x => f x - m / 2 * ‖x‖ ^ 2) x + b • (fun x => f x - m / 2 * ‖x‖ ^ 2) y
state_after: no goals
Theorem: exists_dual_vector'
File: Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean

tactic: by_cases hx : x = 0
state_before: 𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖
state_after: case pos
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖

case neg
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : ¬x = 0
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖

tactic: obtain ⟨y, hy⟩ := exists_ne (0 : E)
state_before: case pos
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖
state_after: case pos.intro
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
y : E
hy : y ≠ 0
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖

tactic: obtain ⟨g, hg⟩ : ∃ g : E →L[𝕜] 𝕜, ‖g‖ = 1 ∧ g y = ‖y‖ := exists_dual_vector 𝕜 y hy
state_before: case pos.intro
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
y : E
hy : y ≠ 0
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖
state_after: case pos.intro.intro
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
y : E
hy : y ≠ 0
g : E →L[𝕜] 𝕜
hg : ‖g‖ = 1 ∧ g y = ↑‖y‖
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖

tactic: refine ⟨g, hg.left, ?_⟩
state_before: case pos.intro.intro
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
y : E
hy : y ≠ 0
g : E →L[𝕜] 𝕜
hg : ‖g‖ = 1 ∧ g y = ↑‖y‖
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖
state_after: case pos.intro.intro
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
y : E
hy : y ≠ 0
g : E →L[𝕜] 𝕜
hg : ‖g‖ = 1 ∧ g y = ↑‖y‖
⊢ g x = ↑‖x‖

tactic: simp [hx]
state_before: case pos.intro.intro
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : x = 0
y : E
hy : y ≠ 0
g : E →L[𝕜] 𝕜
hg : ‖g‖ = 1 ∧ g y = ↑‖y‖
⊢ g x = ↑‖x‖
state_after: no goals

tactic: exact exists_dual_vector 𝕜 x hx
state_before: case neg
𝕜 : Type v
inst✝³ : RCLike 𝕜
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : Nontrivial E
x : E
hx : ¬x = 0
⊢ ∃ g, ‖g‖ = 1 ∧ g x = ↑‖x‖
state_after: no goals
Theorem: Cycle.subsingleton_reverse_iff
File: Mathlib/Data/List/Cycle.lean

tactic: simp [length_subsingleton_iff]
state_before: α : Type u_1
s : Cycle α
⊢ s.reverse.Subsingleton ↔ s.Subsingleton
state_after: no goals
Theorem: PicardLindelof.proj_of_mem
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: simp only [proj, projIcc_of_mem v.tMin_le_tMax ht]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
t : ℝ
ht : t ∈ Icc v.tMin v.tMax
⊢ ↑(v.proj t) = t
state_after: no goals
Theorem: Polynomial.supDegree_eq_natDegree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: obtain rfl|h := eq_or_ne p 0
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ AddMonoidAlgebra.supDegree id p.toFinsupp = p.natDegree
state_after: case inl
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ AddMonoidAlgebra.supDegree id (toFinsupp 0) = natDegree 0

case inr
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
h : p ≠ 0
⊢ AddMonoidAlgebra.supDegree id p.toFinsupp = p.natDegree

tactic: apply WithBot.coe_injective
state_before: case inr
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
h : p ≠ 0
⊢ AddMonoidAlgebra.supDegree id p.toFinsupp = p.natDegree
state_after: case inr.a
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
h : p ≠ 0
⊢ ↑(AddMonoidAlgebra.supDegree id p.toFinsupp) = ↑p.natDegree

tactic: rw [← AddMonoidAlgebra.supDegree_withBot_some_comp, Function.comp_id, supDegree_eq_degree,
  degree_eq_natDegree h, Nat.cast_withBot]
state_before: case inr.a
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
h : p ≠ 0
⊢ ↑(AddMonoidAlgebra.supDegree id p.toFinsupp) = ↑p.natDegree
state_after: case inr.a
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
h : p ≠ 0
⊢ p.toFinsupp.support.Nonempty

tactic: rwa [support_toFinsupp, nonempty_iff_ne_empty, Ne, support_eq_empty]
state_before: case inr.a
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
h : p ≠ 0
⊢ p.toFinsupp.support.Nonempty
state_after: no goals

tactic: simp
state_before: case inl
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ AddMonoidAlgebra.supDegree id (toFinsupp 0) = natDegree 0
state_after: no goals
Theorem: Set.image2_mk_eq_prod
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ ∀ (x : α × β), x ∈ image2 Prod.mk s t ↔ x ∈ s ×ˢ t
state_after: no goals
Theorem: ZMod.natCast_zmod_eq_zero_iff_dvd
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [← Nat.cast_zero, ZMod.natCast_eq_natCast_iff, Nat.modEq_zero_iff_dvd]
state_before: a b : ℕ
⊢ ↑a = 0 ↔ b ∣ a
state_after: no goals
Theorem: Finset.image_erase
File: Mathlib/Data/Finset/Image.lean

tactic: push_cast [Set.image_diff hf, Set.image_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a : α
⊢ ↑(image f (s.erase a)) = ↑((image f s).erase (f a))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a : α
⊢ f '' ↑s \ {f a} = f '' ↑s \ {f a}

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
hf : Injective f
s : Finset α
a : α
⊢ f '' ↑s \ {f a} = f '' ↑s \ {f a}
state_after: no goals
Theorem: EuclideanGeometry.dist_inversion_inversion
File: Mathlib/Geometry/Euclidean/Inversion/Basic.lean

tactic: dsimp only [inversion]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x y z : P
r R✝ : ℝ
hx : x ≠ c
hy : y ≠ c
R : ℝ
⊢ dist (inversion c R x) (inversion c R y) = R ^ 2 / (dist x c * dist y c) * dist x y
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x y z : P
r R✝ : ℝ
hx : x ≠ c
hy : y ≠ c
R : ℝ
⊢ dist ((R / dist x c) ^ 2 • (x -ᵥ c) +ᵥ c) ((R / dist y c) ^ 2 • (y -ᵥ c) +ᵥ c) =
    R ^ 2 / (dist x c * dist y c) * dist x y

tactic: simp_rw [dist_vadd_cancel_right, dist_eq_norm_vsub V _ c]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x y z : P
r R✝ : ℝ
hx : x ≠ c
hy : y ≠ c
R : ℝ
⊢ dist ((R / dist x c) ^ 2 • (x -ᵥ c) +ᵥ c) ((R / dist y c) ^ 2 • (y -ᵥ c) +ᵥ c) =
    R ^ 2 / (dist x c * dist y c) * dist x y
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x y z : P
r R✝ : ℝ
hx : x ≠ c
hy : y ≠ c
R : ℝ
⊢ dist ((R / ‖x -ᵥ c‖) ^ 2 • (x -ᵥ c)) ((R / ‖y -ᵥ c‖) ^ 2 • (y -ᵥ c)) = R ^ 2 / (‖x -ᵥ c‖ * ‖y -ᵥ c‖) * dist x y

tactic: simpa only [dist_vsub_cancel_right] using
  dist_div_norm_sq_smul (vsub_ne_zero.2 hx) (vsub_ne_zero.2 hy) R
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d x y z : P
r R✝ : ℝ
hx : x ≠ c
hy : y ≠ c
R : ℝ
⊢ dist ((R / ‖x -ᵥ c‖) ^ 2 • (x -ᵥ c)) ((R / ‖y -ᵥ c‖) ^ 2 • (y -ᵥ c)) = R ^ 2 / (‖x -ᵥ c‖ * ‖y -ᵥ c‖) * dist x y
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isNat_natCast
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rintro ⟨⟨⟩⟩
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
n m : ℕ
⊢ IsNat n m → IsNat (↑n) m
state_after: case mk.refl
R : Type u_1
inst✝ : AddMonoidWithOne R
m : ℕ
⊢ IsNat (↑↑m) m

tactic: exact ⟨rfl⟩
state_before: case mk.refl
R : Type u_1
inst✝ : AddMonoidWithOne R
m : ℕ
⊢ IsNat (↑↑m) m
state_after: no goals
Theorem: Padic.norm_le_pow_iff_norm_lt_pow_add_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have aux : ∀ n : ℤ, 0 < ((p : ℝ) ^ n) := by
  apply Nat.zpow_pos_of_pos
  exact hp.1.pos
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)

tactic: by_cases hx0 : x = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : x = 0
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)

case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)

tactic: rw [norm_eq_pow_val hx0]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ n ↔ ↑p ^ (-x.valuation) < ↑p ^ (n + 1)

tactic: have h1p : 1 < (p : ℝ) := mod_cast hp.1.one_lt
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ n ↔ ↑p ^ (-x.valuation) < ↑p ^ (n + 1)
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
h1p : 1 < ↑p
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ n ↔ ↑p ^ (-x.valuation) < ↑p ^ (n + 1)

tactic: have H := zpow_strictMono h1p
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
h1p : 1 < ↑p
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ n ↔ ↑p ^ (-x.valuation) < ↑p ^ (n + 1)
state_after: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
h1p : 1 < ↑p
H : StrictMono fun x => ↑p ^ x
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ n ↔ ↑p ^ (-x.valuation) < ↑p ^ (n + 1)

tactic: rw [H.le_iff_le, H.lt_iff_lt, Int.lt_add_one_iff]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : ¬x = 0
h1p : 1 < ↑p
H : StrictMono fun x => ↑p ^ x
⊢ ↑p ^ (-x.valuation) ≤ ↑p ^ n ↔ ↑p ^ (-x.valuation) < ↑p ^ (n + 1)
state_after: no goals

tactic: apply Nat.zpow_pos_of_pos
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
⊢ ∀ (n : ℤ), 0 < ↑p ^ n
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
⊢ 0 < p

tactic: exact hp.1.pos
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
⊢ 0 < p
state_after: no goals

tactic: simp [hx0, norm_zero, aux, le_of_lt (aux _)]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x : ℚ_[p]
n : ℤ
aux : ∀ (n : ℤ), 0 < ↑p ^ n
hx0 : x = 0
⊢ ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)
state_after: no goals
Theorem: Equiv.Perm.IsCycleOn.exists_pow_eq'
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: lift s to Finset α using id hs
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hs : s.Finite
hf : f.IsCycleOn s
ha : a ∈ s
hb : b ∈ s
⊢ ∃ n, (f ^ n) a = b
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
t : Set α
a b x y : α
s : Finset α
hs : (↑s).Finite
hf : f.IsCycleOn ↑s
ha : a ∈ ↑s
hb : b ∈ ↑s
⊢ ∃ n, (f ^ n) a = b

tactic: obtain ⟨n, -, hn⟩ := hf.exists_pow_eq ha hb
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
t : Set α
a b x y : α
s : Finset α
hs : (↑s).Finite
hf : f.IsCycleOn ↑s
ha : a ∈ ↑s
hb : b ∈ ↑s
⊢ ∃ n, (f ^ n) a = b
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
t : Set α
a b x y : α
s : Finset α
hs : (↑s).Finite
hf : f.IsCycleOn ↑s
ha : a ∈ ↑s
hb : b ∈ ↑s
n : ℕ
hn : (f ^ n) a = b
⊢ ∃ n, (f ^ n) a = b

tactic: exact ⟨n, hn⟩
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
t : Set α
a b x y : α
s : Finset α
hs : (↑s).Finite
hf : f.IsCycleOn ↑s
ha : a ∈ ↑s
hb : b ∈ ↑s
n : ℕ
hn : (f ^ n) a = b
⊢ ∃ n, (f ^ n) a = b
state_after: no goals
Theorem: padicValNat.self
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: have neq_one : ¬p = 1 ↔ True := iff_of_true hp.ne' trivial
state_before: p : ℕ
hp : 1 < p
⊢ padicValNat p p = 1
state_after: p : ℕ
hp : 1 < p
neq_one : ¬p = 1 ↔ True
⊢ padicValNat p p = 1

tactic: have eq_zero_false : p = 0 ↔ False := iff_false_intro (zero_lt_one.trans hp).ne'
state_before: p : ℕ
hp : 1 < p
neq_one : ¬p = 1 ↔ True
⊢ padicValNat p p = 1
state_after: p : ℕ
hp : 1 < p
neq_one : ¬p = 1 ↔ True
eq_zero_false : p = 0 ↔ False
⊢ padicValNat p p = 1

tactic: simp [padicValNat, neq_one, eq_zero_false]
state_before: p : ℕ
hp : 1 < p
neq_one : ¬p = 1 ↔ True
eq_zero_false : p = 0 ↔ False
⊢ padicValNat p p = 1
state_after: no goals
Theorem: SetTheory.PGame.lf_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
state_before: xl xr : Type u
x y : PGame
⊢ y ⧏ -x ↔ x ⧏ -y
state_after: no goals
Theorem: abs_norm_sub_norm_le'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa [dist_eq_norm_div] using abs_dist_sub_le a b 1
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ |‖a‖ - ‖b‖| ≤ ‖a / b‖
state_after: no goals
Theorem: Dioph.diophFn_vec_comp1
File: Mathlib/NumberTheory/Dioph.lean

tactic: dsimp
state_before: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ v ∈ {v | f v ::ₒ v ∈ {v | (v ∘ none :: some) ∈ S}} ↔ v ∈ {v | (f v :: v) ∈ S}
state_after: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) ∈ S ↔ v ∈ {v | (f v :: v) ∈ S}

tactic: refine iff_of_eq (congrFun (congrArg Membership.mem ?_) S)
state_before: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) ∈ S ↔ v ∈ {v | (f v :: v) ∈ S}
state_after: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) = f v :: v

tactic: ext x
state_before: α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
⊢ ((f v ::ₒ v) ∘ none :: some) = f v :: v
state_after: case h
α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
x : Fin2 (n + 1)
⊢ ((f v ::ₒ v) ∘ none :: some) x = (f v :: v) x

tactic: cases x <;> rfl
state_before: case h
α β : Type
n : ℕ
S : Set (Vector3 ℕ n.succ)
d : Dioph S
f : Vector3 ℕ n → ℕ
df : DiophFn f
v : Fin2 n → ℕ
x : Fin2 (n + 1)
⊢ ((f v ::ₒ v) ∘ none :: some) x = (f v :: v) x
state_after: no goals
Theorem: Real.pi_gt_three
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: pi_lower_bound [23/16]
state_before: ⊢ 3 < π
state_after: no goals
Theorem: ContDiffAt.sum
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: rw [← contDiffWithinAt_univ] at *
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
ι : Type u_3
f : ι → E → F
s : Finset ι
x : E
h : ∀ i ∈ s, ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffAt 𝕜 n (fun x => ∑ i ∈ s, f i x) x
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
ι : Type u_3
f : ι → E → F
s : Finset ι
x : E
h : ∀ i ∈ s, ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i ∈ s, f i x) univ x

tactic: exact ContDiffWithinAt.sum h
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s✝ s₁ t u : Set E
f✝ f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
ι : Type u_3
f : ι → E → F
s : Finset ι
x : E
h : ∀ i ∈ s, ContDiffAt 𝕜 n (fun x => f i x) x
⊢ ContDiffWithinAt 𝕜 n (fun x => ∑ i ∈ s, f i x) univ x
state_after: no goals