1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: contDiffAt_inv
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: simpa only [Ring.inverse_eq_inv'] using contDiffAt_ring_inverse 𝕜 (Units.mk0 x hx)
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
R : Type u_3
inst✝⁴ : NormedRing R
inst✝³ : NormedAlgebra 𝕜 R
𝕜' : Type u_4
inst✝² : NormedField 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : CompleteSpace 𝕜'
x : 𝕜'
hx : x ≠ 0
n : ℕ∞
⊢ ContDiffAt 𝕜 n Inv.inv x
state_after: no goals
Theorem: Nat.factors_sublist_right
File: Mathlib/Data/Nat/Factors.lean

tactic: cases' n with hn
state_before: n k : ℕ
h : k ≠ 0
⊢ n.factors <+ (n * k).factors
state_after: case zero
k : ℕ
h : k ≠ 0
⊢ factors 0 <+ (0 * k).factors

case succ
k : ℕ
h : k ≠ 0
hn : ℕ
⊢ (hn + 1).factors <+ ((hn + 1) * k).factors

tactic: apply sublist_of_subperm_of_sorted _ (factors_sorted _) (factors_sorted _)
state_before: case succ
k : ℕ
h : k ≠ 0
hn : ℕ
⊢ (hn + 1).factors <+ ((hn + 1) * k).factors
state_after: k : ℕ
h : k ≠ 0
hn : ℕ
⊢ (hn + 1).factors <+~ ((hn + 1) * k).factors

tactic: simp only [(perm_factors_mul (Nat.succ_ne_zero _) h).subperm_left]
state_before: k : ℕ
h : k ≠ 0
hn : ℕ
⊢ (hn + 1).factors <+~ ((hn + 1) * k).factors
state_after: k : ℕ
h : k ≠ 0
hn : ℕ
⊢ (hn + 1).factors <+~ hn.succ.factors ++ k.factors

tactic: exact (sublist_append_left _ _).subperm
state_before: k : ℕ
h : k ≠ 0
hn : ℕ
⊢ (hn + 1).factors <+~ hn.succ.factors ++ k.factors
state_after: no goals

tactic: simp [zero_mul]
state_before: case zero
k : ℕ
h : k ≠ 0
⊢ factors 0 <+ (0 * k).factors
state_after: no goals
Theorem: Inseparable.nhds_le_uniformity
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rw [h.prod rfl]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
x y : α
h : Inseparable x y
⊢ 𝓝 (x, y) ≤ 𝓤 α
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
x y : α
h : Inseparable x y
⊢ 𝓝 (y, y) ≤ 𝓤 α

tactic: apply nhds_le_uniformity
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
x y : α
h : Inseparable x y
⊢ 𝓝 (y, y) ≤ 𝓤 α
state_after: no goals
Theorem: CategoryTheory.BraidedCategory.yang_baxter'
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

tactic: rw [← cancel_epi (α_ X Y Z).inv, ← cancel_mono (α_ Z Y X).hom]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X =
    𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    ((α_ X Y Z).inv ≫
        𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom

tactic: convert yang_baxter X Y Z using 1
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    ((α_ X Y Z).inv ≫
        𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom
state_after: case h.e'_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    (α_ X Y Z).inv ≫
      (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv ≫ (β_ Y Z).hom ▷ X ≫ (α_ Z Y X).hom

case h.e'_3
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ 𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom =
    X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom

tactic: all_goals coherence
state_before: case h.e'_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    (α_ X Y Z).inv ≫
      (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv ≫ (β_ Y Z).hom ▷ X ≫ (α_ Z Y X).hom

case h.e'_3
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ 𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom =
    X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom
state_after: no goals

tactic: coherence
state_before: case h.e'_3
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ 𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom =
    X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom
state_after: no goals
Theorem: AddMonoidAlgebra.mapDomain_one
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: simp_rw [one_def, mapDomain_single, map_zero]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁵ : Semiring k
α : Type u_3
β : Type u_4
α₂ : Type u_5
inst✝⁴ : Semiring β
inst✝³ : Zero α
inst✝² : Zero α₂
F : Type u_6
inst✝¹ : FunLike F α α₂
inst✝ : ZeroHomClass F α α₂
f : F
⊢ mapDomain (⇑f) 1 = 1
state_after: no goals
Theorem: padicNorm.nonneg
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [hq, padicNorm]
state_before: p : ℕ
q : ℚ
hq : q = 0
⊢ 0 ≤ padicNorm p q
state_after: no goals

tactic: unfold padicNorm
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ padicNorm p q
state_after: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ if q = 0 then 0 else ↑p ^ (-padicValRat p q)

tactic: split_ifs
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ if q = 0 then 0 else ↑p ^ (-padicValRat p q)
state_after: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p ^ (-padicValRat p q)

tactic: apply zpow_nonneg
state_before: p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p ^ (-padicValRat p q)
state_after: case ha
p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p

tactic: exact mod_cast Nat.zero_le _
state_before: case ha
p : ℕ
q : ℚ
hq : ¬q = 0
⊢ 0 ≤ ↑p
state_after: no goals
Theorem: Finsupp.indicator_injective
File: Mathlib/Data/Finsupp/Indicator.lean

tactic: intro a b h
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
⊢ Injective fun f => indicator s f
state_after: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
⊢ a = b

tactic: ext i hi
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
⊢ a = b
state_after: case h.h
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
i : ι
hi : i ∈ s
⊢ a i hi = b i hi

tactic: rw [← indicator_of_mem hi a, ← indicator_of_mem hi b]
state_before: case h.h
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
i : ι
hi : i ∈ s
⊢ a i hi = b i hi
state_after: case h.h
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
i : ι
hi : i ∈ s
⊢ (indicator s a) i = (indicator s b) i

tactic: exact DFunLike.congr_fun h i
state_before: case h.h
ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f : (i : ι) → i ∈ s → α
i✝ : ι
a b : (i : ι) → i ∈ s → α
h : (fun f => indicator s f) a = (fun f => indicator s f) b
i : ι
hi : i ∈ s
⊢ (indicator s a) i = (indicator s b) i
state_after: no goals
Theorem: Real.convexOn_Gamma
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

tactic: refine
  ((convexOn_exp.subset (subset_univ _) ?_).comp convexOn_log_Gamma
        (exp_monotone.monotoneOn _)).congr
    fun x hx => exp_log (Gamma_pos_of_pos hx)
state_before: ⊢ ConvexOn ℝ (Ioi 0) Gamma
state_after: ⊢ Convex ℝ (log ∘ Gamma '' Ioi 0)

tactic: rw [convex_iff_isPreconnected]
state_before: ⊢ Convex ℝ (log ∘ Gamma '' Ioi 0)
state_after: ⊢ IsPreconnected (log ∘ Gamma '' Ioi 0)

tactic: refine isPreconnected_Ioi.image _ fun x hx => ContinuousAt.continuousWithinAt ?_
state_before: ⊢ IsPreconnected (log ∘ Gamma '' Ioi 0)
state_after: x : ℝ
hx : x ∈ Ioi 0
⊢ ContinuousAt (log ∘ Gamma) x

tactic: refine (differentiableAt_Gamma fun m => ?_).continuousAt.log (Gamma_pos_of_pos hx).ne'
state_before: x : ℝ
hx : x ∈ Ioi 0
⊢ ContinuousAt (log ∘ Gamma) x
state_after: x : ℝ
hx : x ∈ Ioi 0
m : ℕ
⊢ x ≠ -↑m

tactic: exact (neg_lt_iff_pos_add.mpr (add_pos_of_pos_of_nonneg (mem_Ioi.mp hx) (Nat.cast_nonneg m))).ne'
state_before: x : ℝ
hx : x ∈ Ioi 0
m : ℕ
⊢ x ≠ -↑m
state_after: no goals
Theorem: Ideal.unit_mul_mem_iff_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: refine ⟨fun h => ?_, fun h => I.mul_mem_left y h⟩
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
⊢ y * x ∈ I ↔ x ∈ I
state_after: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
⊢ x ∈ I

tactic: obtain ⟨y', hy'⟩ := hy.exists_left_inv
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
⊢ x ∈ I
state_after: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
y' : α
hy' : y' * y = 1
⊢ x ∈ I

tactic: have := I.mul_mem_left y' h
state_before: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
y' : α
hy' : y' * y = 1
⊢ x ∈ I
state_after: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
y' : α
hy' : y' * y = 1
this : y' * (y * x) ∈ I
⊢ x ∈ I

tactic: rwa [← mul_assoc, hy', one_mul] at this
state_before: case intro
α : Type u
β : Type v
inst✝ : Semiring α
I : Ideal α
a b x y : α
hy : IsUnit y
h : y * x ∈ I
y' : α
hy' : y' * y = 1
this : y' * (y * x) ∈ I
⊢ x ∈ I
state_after: no goals
Theorem: PowerSeries.eq_X_mul_shift_add_const
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext (_ | n)
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ φ = (X * mk fun p => (coeff R (p + 1)) φ) + (C R) ((constantCoeff R) φ)
state_after: case h.zero
R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (coeff R 0) φ = (coeff R 0) ((X * mk fun p => (coeff R (p + 1)) φ) + (C R) ((constantCoeff R) φ))

case h.succ
R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
n : ℕ
⊢ (coeff R (n + 1)) φ = (coeff R (n + 1)) ((X * mk fun p => (coeff R (p + 1)) φ) + (C R) ((constantCoeff R) φ))

tactic: simp only [Nat.zero_eq, coeff_zero_eq_constantCoeff, map_add, map_mul, constantCoeff_X,
  zero_mul, coeff_zero_C, zero_add]
state_before: case h.zero
R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (coeff R 0) φ = (coeff R 0) ((X * mk fun p => (coeff R (p + 1)) φ) + (C R) ((constantCoeff R) φ))
state_after: no goals

tactic: simp only [coeff_succ_X_mul, coeff_mk, LinearMap.map_add, coeff_C, n.succ_ne_zero, sub_zero,
  if_false, add_zero]
state_before: case h.succ
R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
n : ℕ
⊢ (coeff R (n + 1)) φ = (coeff R (n + 1)) ((X * mk fun p => (coeff R (p + 1)) φ) + (C R) ((constantCoeff R) φ))
state_after: no goals
Theorem: Pell.dz_val
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [Pell.d, Int.ofNat_sub this]
state_before: a : ℕ
a1 : 1 < a
this : 1 ≤ a * a
⊢ ↑(Pell.d a1) = az a * az a - 1
state_after: a : ℕ
a1 : 1 < a
this : 1 ≤ a * a
⊢ ↑(a * a) - ↑1 = az a * az a - 1

tactic: rfl
state_before: a : ℕ
a1 : 1 < a
this : 1 ≤ a * a
⊢ ↑(a * a) - ↑1 = az a * az a - 1
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.FinMeasSupp.mul
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [mul_eq_map₂]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_5
inst✝ : MonoidWithZero β
f g : α →ₛ β
hf : f.FinMeasSupp μ
hg : g.FinMeasSupp μ
⊢ (f * g).FinMeasSupp μ
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_5
inst✝ : MonoidWithZero β
f g : α →ₛ β
hf : f.FinMeasSupp μ
hg : g.FinMeasSupp μ
⊢ (map (fun p => p.1 * p.2) (f.pair g)).FinMeasSupp μ

tactic: exact hf.map₂ hg (zero_mul 0)
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
inst✝² : Zero β✝
inst✝¹ : Zero γ
μ : Measure α
f✝ : α →ₛ β✝
β : Type u_5
inst✝ : MonoidWithZero β
f g : α →ₛ β
hf : f.FinMeasSupp μ
hg : g.FinMeasSupp μ
⊢ (map (fun p => p.1 * p.2) (f.pair g)).FinMeasSupp μ
state_after: no goals
Theorem: Fin.castSucc_ne_zero_of_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
p i : Fin n
h : p < i
⊢ i.castSucc ≠ 0
state_after: case zero
m : ℕ
p i : Fin 0
h : p < i
⊢ i.castSucc ≠ 0

case succ
m n✝ : ℕ
p i : Fin (n✝ + 1)
h : p < i
⊢ i.castSucc ≠ 0

tactic: exact i.elim0
state_before: case zero
m : ℕ
p i : Fin 0
h : p < i
⊢ i.castSucc ≠ 0
state_after: no goals

tactic: rw [castSucc_ne_zero_iff', Ne, ext_iff]
state_before: case succ
m n✝ : ℕ
p i : Fin (n✝ + 1)
h : p < i
⊢ i.castSucc ≠ 0
state_after: case succ
m n✝ : ℕ
p i : Fin (n✝ + 1)
h : p < i
⊢ ¬↑i = ↑0

tactic: exact ((zero_le _).trans_lt h).ne'
state_before: case succ
m n✝ : ℕ
p i : Fin (n✝ + 1)
h : p < i
⊢ ¬↑i = ↑0
state_after: no goals
Theorem: Filter.pow_mem_pow
File: Mathlib/Order/Filter/Pointwise.lean

tactic: rw [pow_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ s ^ 0 ∈ f ^ 0
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ 1 ∈ f ^ 0

tactic: exact one_mem_one
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hs : s ∈ f
⊢ 1 ∈ f ^ 0
state_after: no goals

tactic: rw [pow_succ]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ (n + 1) ∈ f ^ (n + 1)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ n * s ∈ f ^ (n + 1)

tactic: exact mul_mem_mul (pow_mem_pow hs n) hs
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n✝ : ℕ
hs : s ∈ f
n : ℕ
⊢ s ^ n * s ∈ f ^ (n + 1)
state_after: no goals
Theorem: SimpleGraph.Subgraph.Connected.adj_union
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

tactic: refine ((top_induce_pair_connected_of_adj huv).sup Hconn ?_).sup Kconn ?_
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ (⊤.induce {u, v} ⊔ H ⊔ K).Connected
state_after: case refine_1
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ (⊤.induce {u, v} ⊓ H).verts.Nonempty

case refine_2
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ ((⊤.induce {u, v} ⊔ H) ⊓ K).verts.Nonempty

tactic: exact ⟨u, by simp [uH]⟩
state_before: case refine_1
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ (⊤.induce {u, v} ⊓ H).verts.Nonempty
state_after: no goals

tactic: simp [uH]
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ u ∈ (⊤.induce {u, v} ⊓ H).verts
state_after: no goals

tactic: exact ⟨v, by simp [vK]⟩
state_before: case refine_2
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ ((⊤.induce {u, v} ⊔ H) ⊓ K).verts.Nonempty
state_after: no goals

tactic: simp [vK]
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H K : G.Subgraph
Hconn : H.Connected
Kconn : K.Connected
u v : V
uH : u ∈ H.verts
vK : v ∈ K.verts
huv : G.Adj u v
⊢ v ∈ ((⊤.induce {u, v} ⊔ H) ⊓ K).verts
state_after: no goals
Theorem: CancelDenoms.inv_subst
File: Mathlib/Tactic/CancelDenoms/Core.lean

tactic: rw [← div_eq_mul_inv, ← h3, mul_div_cancel_right₀ _ h2]
state_before: α : Type u_1
inst✝ : Field α
n k e : α
h2 : e ≠ 0
h3 : n * e = k
⊢ k * e⁻¹ = n
state_after: no goals
Theorem: CauSeq.lt_of_lt_of_eq
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: convert pos_add_limZero fg (neg_limZero gh) using 1
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ (h - f).Pos
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ h - f = g - f + -(g - h)

tactic: simp
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ h - f = g - f + -(g - h)
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.IsUniversal.existsUnique
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
f✝ g✝ : CostructuredArrow S T
h : f✝.IsUniversal
g : CostructuredArrow S T
f : g.left ⟶ f✝.left
w : (fun η => S.map η ≫ f✝.hom = g.hom) f
⊢ S.map f ≫ f✝.hom = S.map (h.lift g) ≫ f✝.hom
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.id_tensorHom
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp [tensorHom_def]
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y₁ Y₂ : C
f : Y₁ ⟶ Y₂
⊢ 𝟙 X ⊗ f = X ◁ f
state_after: no goals
Theorem: ZNum.neg_of_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [Int.cast_neg]
state_before: α : Type u_1
⊢ ↑(-0) = -↑0
state_after: no goals
Theorem: Equiv.Perm.sumCongr_refl_swap
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext x
state_before: α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
⊢ sumCongr (Equiv.refl α) (swap i j) = swap (Sum.inr i) (Sum.inr j)
state_after: case H
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
x : α ⊕ β
⊢ (sumCongr (Equiv.refl α) (swap i j)) x = (swap (Sum.inr i) (Sum.inr j)) x

tactic: cases x
state_before: case H
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
x : α ⊕ β
⊢ (sumCongr (Equiv.refl α) (swap i j)) x = (swap (Sum.inr i) (Sum.inr j)) x
state_after: case H.inl
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
val✝ : α
⊢ (sumCongr (Equiv.refl α) (swap i j)) (Sum.inl val✝) = (swap (Sum.inr i) (Sum.inr j)) (Sum.inl val✝)

case H.inr
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : β
⊢ (sumCongr (Equiv.refl α) (swap i j)) (Sum.inr val✝) = (swap (Sum.inr i) (Sum.inr j)) (Sum.inr val✝)

tactic: simp [Sum.map, swap_apply_of_ne_of_ne]
state_before: case H.inl
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j : β
val✝ : α
⊢ (sumCongr (Equiv.refl α) (swap i j)) (Sum.inl val✝) = (swap (Sum.inr i) (Sum.inr j)) (Sum.inl val✝)
state_after: no goals

tactic: simp only [Equiv.sumCongr_apply, Sum.map, coe_refl, comp_id, Sum.elim_inr, comp_apply,
  swap_apply_def, Sum.inr.injEq]
state_before: case H.inr
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : β
⊢ (sumCongr (Equiv.refl α) (swap i j)) (Sum.inr val✝) = (swap (Sum.inr i) (Sum.inr j)) (Sum.inr val✝)
state_after: case H.inr
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : β
⊢ Sum.inr (if val✝ = i then j else if val✝ = j then i else val✝) =
    if val✝ = i then Sum.inr j else if val✝ = j then Sum.inr i else Sum.inr val✝

tactic: split_ifs <;> rfl
state_before: case H.inr
α✝ : Sort ?u.103054
inst✝² : DecidableEq α✝
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
i j val✝ : β
⊢ Sum.inr (if val✝ = i then j else if val✝ = j then i else val✝) =
    if val✝ = i then Sum.inr j else if val✝ = j then Sum.inr i else Sum.inr val✝
state_after: no goals
Theorem: eq_mul_of_inv_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h.symm, mul_inv_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b⁻¹ * a = c
⊢ a = b * c
state_after: no goals
Theorem: TopologicalSpace.NoetherianSpace.exists_finset_irreducible
File: Mathlib/Topology/NoetherianSpace.lean

tactic: simpa [Set.exists_finite_iff_finset, Finset.sup_id_eq_sSup]
  using NoetherianSpace.exists_finite_set_closeds_irreducible s
state_before: α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Closeds α
⊢ ∃ S, (∀ (k : { x // x ∈ S }), IsIrreducible ↑↑k) ∧ s = S.sup id
state_after: no goals
Theorem: PMF.filter_apply_eq_zero_of_not_mem
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: rw [filter_apply, Set.indicator_apply_eq_zero.mpr fun ha' => absurd ha' ha, zero_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s : Set α
h : ∃ a ∈ s, a ∈ p.support
a : α
ha : a ∉ s
⊢ (p.filter s h) a = 0
state_after: no goals
Theorem: Polynomial.degree_X_pow_sub_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C a, degree_X_pow_add_C hn]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
n : ℕ
hn : 0 < n
a : R
⊢ (X ^ n - C a).degree = ↑n
state_after: no goals
Theorem: WittVector.truncateFun_mul
File: Mathlib/RingTheory/WittVector/Truncated.lean

tactic: witt_truncateFun_tac
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
x y : 𝕎 R
⊢ truncateFun n (x * y) = truncateFun n x * truncateFun n y
state_after: no goals
Theorem: CategoryTheory.Presieve.image_mem_functorPushforward
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
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Presieve X
f : Y ⟶ X
h : R f
⊢ F.map f = 𝟙 (F.obj Y) ≫ F.map f
state_after: no goals