1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ fst ≫ fst = snd
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      fst ≫ fst =
    snd

tactic: simp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      fst ≫ fst =
    snd
state_after: no goals
Theorem: circleMap_mem_sphere'
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ circleMap c R θ ∈ sphere c |R|
state_after: no goals
Theorem: Ordnode.insert'_eq_insertWith
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: unfold insert' insertWith
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ insert' x (node size✝ l y r) = insertWith id x (node size✝ l y r)
state_after: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => (insert' x l).balanceL y r
    | Ordering.eq => node size✝ l y r
    | Ordering.gt => l.balanceR y (insert' x r)) =
    match cmpLE x y with
    | Ordering.lt => (insertWith id x l).balanceL y r
    | Ordering.eq => node size✝ l (id y) r
    | Ordering.gt => l.balanceR y (insertWith id x r)

tactic: cases cmpLE x y <;> simp [insert'_eq_insertWith]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
size✝ : ℕ
l : Ordnode α
y : α
r : Ordnode α
⊢ (match cmpLE x y with
    | Ordering.lt => (insert' x l).balanceL y r
    | Ordering.eq => node size✝ l y r
    | Ordering.gt => l.balanceR y (insert' x r)) =
    match cmpLE x y with
    | Ordering.lt => (insertWith id x l).balanceL y r
    | Ordering.eq => node size✝ l (id y) r
    | Ordering.gt => l.balanceR y (insertWith id x r)
state_after: no goals
Theorem: TypeVec.prod_id
File: Mathlib/Data/TypeVec.lean

tactic: intros
state_before: n : ℕ
⊢ ∀ {n : ℕ} {α β : TypeVec.{u} n}, (id ⊗' id) = id
state_after: n n✝ : ℕ
α✝ β✝ : TypeVec.{u} n✝
⊢ (id ⊗' id) = id

tactic: ext i a
state_before: n n✝ : ℕ
α✝ β✝ : TypeVec.{u} n✝
⊢ (id ⊗' id) = id
state_after: case a.h
n n✝ : ℕ
α✝ β✝ : TypeVec.{u} n✝
i : Fin2 n✝
a : (α✝ ⊗ β✝) i
⊢ (id ⊗' id) i a = id i a

tactic: induction' i with _ _ _ i_ih
state_before: case a.h
n n✝ : ℕ
α✝ β✝ : TypeVec.{u} n✝
i : Fin2 n✝
a : (α✝ ⊗ β✝) i
⊢ (id ⊗' id) i a = id i a
state_after: case a.h.fz
n n✝¹ n✝ : ℕ
α✝ β✝ : TypeVec.{u} (n✝ + 1)
a : (α✝ ⊗ β✝) Fin2.fz
⊢ (id ⊗' id) Fin2.fz a = id Fin2.fz a

case a.h.fs
n n✝¹ n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u} n✝} (a : (α ⊗ β) a✝), (id ⊗' id) a✝ a = id a✝ a
α✝ β✝ : TypeVec.{u} (n✝ + 1)
a : (α✝ ⊗ β✝) a✝.fs
⊢ (id ⊗' id) a✝.fs a = id a✝.fs a

tactic: cases a
state_before: case a.h.fz
n n✝¹ n✝ : ℕ
α✝ β✝ : TypeVec.{u} (n✝ + 1)
a : (α✝ ⊗ β✝) Fin2.fz
⊢ (id ⊗' id) Fin2.fz a = id Fin2.fz a
state_after: case a.h.fz.mk
n n✝¹ n✝ : ℕ
α✝ β✝ : TypeVec.{u} (n✝ + 1)
fst✝ : α✝.last
snd✝ : β✝.last
⊢ (id ⊗' id) Fin2.fz (fst✝, snd✝) = id Fin2.fz (fst✝, snd✝)

tactic: rfl
state_before: case a.h.fz.mk
n n✝¹ n✝ : ℕ
α✝ β✝ : TypeVec.{u} (n✝ + 1)
fst✝ : α✝.last
snd✝ : β✝.last
⊢ (id ⊗' id) Fin2.fz (fst✝, snd✝) = id Fin2.fz (fst✝, snd✝)
state_after: no goals

tactic: apply i_ih
state_before: case a.h.fs
n n✝¹ n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u} n✝} (a : (α ⊗ β) a✝), (id ⊗' id) a✝ a = id a✝ a
α✝ β✝ : TypeVec.{u} (n✝ + 1)
a : (α✝ ⊗ β✝) a✝.fs
⊢ (id ⊗' id) a✝.fs a = id a✝.fs a
state_after: no goals
Theorem: Asymptotics.isBigOWith_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [IsBigOWith_def]
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 α
⊢ IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖
state_after: no goals
Theorem: pairwise_subtype_iff_pairwise_set
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [Pairwise, Set.Pairwise, SetCoe.forall, Ne, Subtype.ext_iff, Subtype.coe_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r✝ p q : α → α → Prop
s : Set α
r : α → α → Prop
⊢ (Pairwise fun x y => r ↑x ↑y) ↔ s.Pairwise r
state_after: no goals
Theorem: mulDissociated_singleton
File: Mathlib/Combinatorics/Additive/Dissociation.lean

tactic: simp [MulDissociated, setOf_or, (Finset.singleton_ne_empty _).symm, -subset_singleton_iff,
  Finset.coe_subset_singleton]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
⊢ MulDissociated {a} ↔ a ≠ 1
state_after: no goals
Theorem: ENNReal.iInf_add_iInf
File: Mathlib/Data/ENNReal/Real.lean

tactic: simp_rw [iInf_add, add_iInf]
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ∀ (i j : ι), ∃ k, f k + g k ≤ f i + g j
⊢ ⨅ a, ⨅ a', f a + g a' = iInf f + iInf g
state_after: no goals
Theorem: IntermediateField.coe_iInf
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp [iInf]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
ι : Sort u_3
S : ι → IntermediateField F E
⊢ ↑(iInf S) = ⋂ i, ↑(S i)
state_after: no goals
Theorem: List.Perm.diff_right
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: exact h
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
h : l₁ ~ l₂
⊢ l₁ ~ l₂
state_after: no goals

tactic: simp only [elem_eq_mem, decide_eq_true_eq, Perm.mem_iff h]
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
⊢ (if elem x l₁ = true then (l₁.erase x).diff t else l₁.diff t) ~
    if elem x l₂ = true then (l₂.erase x).diff t else l₂.diff t
state_after: case cons
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
⊢ (if x ∈ l₂ then (l₁.erase x).diff t else l₁.diff t) ~ if x ∈ l₂ then (l₂.erase x).diff t else l₂.diff t

tactic: split
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
⊢ (if x ∈ l₂ then (l₁.erase x).diff t else l₁.diff t) ~ if x ∈ l₂ then (l₂.erase x).diff t else l₂.diff t
state_after: case cons.isTrue
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
h✝ : x ∈ l₂
⊢ (l₁.erase x).diff t ~ (l₂.erase x).diff t

case cons.isFalse
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
h✝ : ¬x ∈ l₂
⊢ l₁.diff t ~ l₂.diff t

tactic: exact ih (h.erase _)
state_before: case cons.isTrue
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
h✝ : x ∈ l₂
⊢ (l₁.erase x).diff t ~ (l₂.erase x).diff t
state_after: no goals

tactic: exact ih h
state_before: case cons.isFalse
α : Type u_1
inst✝ : DecidableEq α
x : α
t : List α
ih : ∀ {l₁ l₂ : List α}, l₁ ~ l₂ → l₁.diff t ~ l₂.diff t
l₁ l₂ : List α
h : l₁ ~ l₂
h✝ : ¬x ∈ l₂
⊢ l₁.diff t ~ l₂.diff t
state_after: no goals
Theorem: PartialHomeomorph.extend_target_mem_nhdsWithin
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [← PartialEquiv.image_source_eq_target, ← map_extend_nhds f I hy]
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
⊢ (f.extend I).target ∈ 𝓝[range ↑I] ↑(f.extend I) y
state_after: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
⊢ ↑(f.extend I) '' (f.extend I).source ∈ map (↑(f.extend I)) (𝓝 y)

tactic: exact image_mem_map (extend_source_mem_nhds _ _ hy)
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
y : M
hy : y ∈ f.source
⊢ ↑(f.extend I) '' (f.extend I).source ∈ map (↑(f.extend I)) (𝓝 y)
state_after: no goals
Theorem: Polynomial.eta
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: cases f
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q f : R[X]
⊢ { toFinsupp := f.toFinsupp } = f
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝ : R[ℕ]
⊢ { toFinsupp := { toFinsupp := toFinsupp✝ }.toFinsupp } = { toFinsupp := toFinsupp✝ }

tactic: rfl
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝ : R[ℕ]
⊢ { toFinsupp := { toFinsupp := toFinsupp✝ }.toFinsupp } = { toFinsupp := toFinsupp✝ }
state_after: no goals
Theorem: ZMod.natAbs_valMinAbs_neg
File: Mathlib/Data/ZMod/Basic.lean

tactic: by_cases h2a : 2 * a.val = n
state_before: n : ℕ
a : ZMod n
⊢ (-a).valMinAbs.natAbs = a.valMinAbs.natAbs
state_after: case pos
n : ℕ
a : ZMod n
h2a : 2 * a.val = n
⊢ (-a).valMinAbs.natAbs = a.valMinAbs.natAbs

case neg
n : ℕ
a : ZMod n
h2a : ¬2 * a.val = n
⊢ (-a).valMinAbs.natAbs = a.valMinAbs.natAbs

tactic: rw [a.neg_eq_self_iff.2 (Or.inr h2a)]
state_before: case pos
n : ℕ
a : ZMod n
h2a : 2 * a.val = n
⊢ (-a).valMinAbs.natAbs = a.valMinAbs.natAbs
state_after: no goals

tactic: rw [valMinAbs_neg_of_ne_half h2a, Int.natAbs_neg]
state_before: case neg
n : ℕ
a : ZMod n
h2a : ¬2 * a.val = n
⊢ (-a).valMinAbs.natAbs = a.valMinAbs.natAbs
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.comp_left_iff
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: refine ⟨fun hg => ?_, fun hg => h.comp hg⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving (⇑e) μb μc
⊢ MeasurePreserving (⇑e ∘ g) μa μc ↔ MeasurePreserving g μa μb
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving (⇑e) μb μc
hg : MeasurePreserving (⇑e ∘ g) μa μc
⊢ MeasurePreserving g μa μb

tactic: convert (MeasurePreserving.symm e h).comp hg
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving (⇑e) μb μc
hg : MeasurePreserving (⇑e ∘ g) μa μc
⊢ MeasurePreserving g μa μb
state_after: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving (⇑e) μb μc
hg : MeasurePreserving (⇑e ∘ g) μa μc
⊢ g = ⇑e.symm ∘ ⇑e ∘ g

tactic: simp [← Function.comp.assoc e.symm e g]
state_before: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
g : α → β
e : β ≃ᵐ γ
h : MeasurePreserving (⇑e) μb μc
hg : MeasurePreserving (⇑e ∘ g) μa μc
⊢ g = ⇑e.symm ∘ ⇑e ∘ g
state_after: no goals
Theorem: calc_norm_le_one
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [hz.1]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖↑(Polynomial.eval z F)‖ / ‖↑(Polynomial.eval z (Polynomial.derivative F))‖ =
    ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
state_after: no goals

tactic: gcongr
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖ ≤
    ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n /
      ‖Polynomial.eval a (Polynomial.derivative F)‖
state_after: case hab
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n

tactic: apply hz.2
state_before: case hab
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n
state_after: no goals
Theorem: HahnSeries.single_injective
File: Mathlib/RingTheory/HahnSeries/Basic.lean

tactic: rw [← single_coeff_same a r, ← single_coeff_same a s, rs]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r s : R
rs : (single a) r = (single a) s
⊢ r = s
state_after: no goals
Theorem: BoxIntegral.Box.nndist_le_distortion_mul
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: apply mul_le_mul_right'
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
⊢ nndist I.lower I.upper / nndist (I.lower i) (I.upper i) * nndist (I.lower i) (I.upper i) ≤
    I.distortion * nndist (I.lower i) (I.upper i)
state_after: case bc
ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
⊢ nndist I.lower I.upper / nndist (I.lower i) (I.upper i) ≤ I.distortion

tactic: apply Finset.le_sup (Finset.mem_univ i)
state_before: case bc
ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
⊢ nndist I.lower I.upper / nndist (I.lower i) (I.upper i) ≤ I.distortion
state_after: no goals
Theorem: BoundedVariationOn.sub_le
File: Mathlib/Analysis/BoundedVariation.lean

tactic: apply (le_abs_self _).trans
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → ℝ
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ f x - f y ≤ (eVariationOn f s).toReal
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → ℝ
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ |f x - f y| ≤ (eVariationOn f s).toReal

tactic: rw [← Real.dist_eq]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → ℝ
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ |f x - f y| ≤ (eVariationOn f s).toReal
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → ℝ
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ dist (f x) (f y) ≤ (eVariationOn f s).toReal

tactic: exact h.dist_le hx hy
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → ℝ
s : Set α
h : BoundedVariationOn f s
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ dist (f x) (f y) ≤ (eVariationOn f s).toReal
state_after: no goals
Theorem: RCLike.div_re
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: simp only [div_eq_mul_inv, mul_assoc, sub_eq_add_neg, neg_mul, mul_neg, neg_neg, map_neg,
  rclike_simps]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z w : K
⊢ re (z / w) = re z * re w / normSq w + im z * im w / normSq w
state_after: no goals
Theorem: edist_le_tsum_of_edist_le_of_tendsto₀
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simpa using edist_le_tsum_of_edist_le_of_tendsto d hf ha 0
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
⊢ edist (f 0) a ≤ ∑' (m : ℕ), d m
state_after: no goals
Theorem: Finset.powerset_sups_powerset_self
File: Mathlib/Data/Finset/Sups.lean

tactic: simp [← powerset_union]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
𝒜 ℬ : Finset (Finset α)
s✝ t : Finset α
a : α
s : Finset α
⊢ s.powerset ⊻ s.powerset = s.powerset
state_after: no goals
Theorem: Ordnode.Sized.balance'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: unfold balance'
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (l.balance' x r).Sized
state_after: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (if l.size + r.size ≤ 1 then l.node' x r
    else
      if r.size > delta * l.size then l.rotateL x r
      else if l.size > delta * r.size then l.rotateR x r else l.node' x r).Sized

tactic: split_ifs
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (if l.size + r.size ≤ 1 then l.node' x r
    else
      if r.size > delta * l.size then l.rotateL x r
      else if l.size > delta * r.size then l.rotateR x r else l.node' x r).Sized
state_after: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝ : l.size + r.size ≤ 1
⊢ (l.node' x r).Sized

case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝¹ : ¬l.size + r.size ≤ 1
h✝ : r.size > delta * l.size
⊢ (l.rotateL x r).Sized

case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝² : ¬l.size + r.size ≤ 1
h✝¹ : ¬r.size > delta * l.size
h✝ : l.size > delta * r.size
⊢ (l.rotateR x r).Sized

case neg
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝² : ¬l.size + r.size ≤ 1
h✝¹ : ¬r.size > delta * l.size
h✝ : ¬l.size > delta * r.size
⊢ (l.node' x r).Sized

tactic: exact hl.node' hr
state_before: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝ : l.size + r.size ≤ 1
⊢ (l.node' x r).Sized
state_after: no goals

tactic: exact hl.rotateL hr
state_before: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝¹ : ¬l.size + r.size ≤ 1
h✝ : r.size > delta * l.size
⊢ (l.rotateL x r).Sized
state_after: no goals

tactic: exact hl.rotateR hr
state_before: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝² : ¬l.size + r.size ≤ 1
h✝¹ : ¬r.size > delta * l.size
h✝ : l.size > delta * r.size
⊢ (l.rotateR x r).Sized
state_after: no goals

tactic: exact hl.node' hr
state_before: case neg
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝² : ¬l.size + r.size ≤ 1
h✝¹ : ¬r.size > delta * l.size
h✝ : ¬l.size > delta * r.size
⊢ (l.node' x r).Sized
state_after: no goals
Theorem: commProb_pi
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: simp_rw [commProb_def, Finset.prod_div_distrib, Finset.prod_pow, ← Nat.cast_prod,
  ← Nat.card_pi, Commute, SemiconjBy, Function.funext_iff]
state_before: M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ commProb ((a : α) → i a) = ∏ a : α, commProb (i a)
state_after: M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ ↑(Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a }) / ↑(Nat.card ((a : α) → i a)) ^ 2 =
    ↑(Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })) / ↑(Nat.card ((a : α) → i a)) ^ 2

tactic: congr 2
state_before: M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ ↑(Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a }) / ↑(Nat.card ((a : α) → i a)) ^ 2 =
    ↑(Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })) / ↑(Nat.card ((a : α) → i a)) ^ 2
state_after: case e_a.e_a
M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a } = Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })

tactic: exact Nat.card_congr ⟨fun x a => ⟨⟨x.1.1 a, x.1.2 a⟩, x.2 a⟩, fun x => ⟨⟨fun a => (x a).1.1,
  fun a => (x a).1.2⟩, fun a => (x a).2⟩, fun x => rfl, fun x => rfl⟩
state_before: case e_a.e_a
M : Type u_1
inst✝² : Mul M
α : Type u_2
i : α → Type u_3
inst✝¹ : Fintype α
inst✝ : (a : α) → Mul (i a)
⊢ Nat.card { p // ∀ (a : α), (p.1 * p.2) a = (p.2 * p.1) a } = Nat.card ((a : α) → { p // p.1 * p.2 = p.2 * p.1 })
state_after: no goals
Theorem: Filter.frequently_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
⊢ ¬∃ᶠ (x : α) in ⊥, p x
state_after: no goals