ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.dist_pos_of_ne
File: Mathlib/Data/Nat/Dist.lean

Proof steps:
state_before: i j : ℕ
hne : i ≠ j
h : i < j
⊢ 0 < i.dist j
state_after: i j : ℕ
hne : i ≠ j
h : i < j
⊢ 0 < j - i
tactic: rw [dist_eq_sub_of_le (le_of_lt h)]
state_before: i j : ℕ
hne : i ≠ j
h : i < j
⊢ 0 < j - i
state_after: no goals
tactic: apply tsub_pos_of_lt h
state_before: i j : ℕ
hne : i ≠ j
h : i = j
⊢ 0 < i.dist j
state_after: no goals
tactic: contradiction
state_before: i j : ℕ
hne : i ≠ j
h : i > j
⊢ 0 < i.dist j
state_after: i j : ℕ
hne : i ≠ j
h : i > j
⊢ 0 < i - j
tactic: rw [dist_eq_sub_of_le_right (le_of_lt h)]
state_before: i j : ℕ
hne : i ≠ j
h : i > j
⊢ 0 < i - j
state_after: no goals
tactic: apply tsub_pos_of_lt h
Theorem: HNNExtension.NormalWord.prod_unitsSMul
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
⊢ ReducedWord.prod φ (unitsSMul φ u w).toReducedWord = t ^ ↑u * ReducedWord.prod φ w.toReducedWord
state_after: G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
⊢ ReducedWord.prod φ
      (if h : Cancels u w then unitsSMulWithCancel φ u w h
        else
          let g' := unitsSMulGroup φ d u w.head;
          cons (↑g'.1) u ((↑g'.2 * w.head⁻¹) • w) ⋯ ⋯).toReducedWord =
    t ^ ↑u * ReducedWord.prod φ w.toReducedWord
tactic: rw [unitsSMul]
state_before: G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
⊢ ReducedWord.prod φ
      (if h : Cancels u w then unitsSMulWithCancel φ u w h
        else
          let g' := unitsSMulGroup φ d u w.head;
          cons (↑g'.1) u ((↑g'.2 * w.head⁻¹) • w) ⋯ ⋯).toReducedWord =
    t ^ ↑u * ReducedWord.prod φ w.toReducedWord
state_after: case pos
G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
hcan : Cancels u w
⊢ ReducedWord.prod φ (unitsSMulWithCancel φ u w hcan).toReducedWord = t ^ ↑u * ReducedWord.prod φ w.toReducedWord

case neg
G : Type u_1
inst✝³ : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝² : Group H
M : Type u_3
inst✝¹ : Monoid M
d : TransversalPair G A B
inst✝ : DecidableEq G
u : ℤˣ
w : NormalWord d
hcan : ¬Cancels u w
⊢ ReducedWord.prod φ
      (let g' := unitsSMulGroup φ d u w.head;
        cons (↑g'.1) u ((↑g'.2 * w.head⁻¹) • w) ⋯ ⋯).toReducedWord =
    t ^ ↑u * ReducedWord.prod φ w.toReducedWord
tactic: split_ifs with hcan
Theorem: Quaternion.normSq_neg
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ normSq (-a) = normSq a
state_after: no goals
tactic: simp only [normSq_def, star_neg, neg_mul_neg]
Theorem: Polynomial.scaleRoots_aeval_eq_zero
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝⁴ : Semiring S
inst✝³ : CommSemiring R
inst✝² : Semiring A
inst✝¹ : Field K
inst✝ : Algebra R A
p : R[X]
a : A
r : R
ha : (aeval a) p = 0
⊢ (aeval ((algebraMap R A) r * a)) (p.scaleRoots r) = 0
state_after: case hsa
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝⁴ : Semiring S
inst✝³ : CommSemiring R
inst✝² : Semiring A
inst✝¹ : Field K
inst✝ : Algebra R A
p : R[X]
a : A
r : R
ha : (aeval a) p = 0
⊢ Commute ((algebraMap R A) r) a

case hf
R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝⁴ : Semiring S
inst✝³ : CommSemiring R
inst✝² : Semiring A
inst✝¹ : Field K
inst✝ : Algebra R A
p : R[X]
a : A
r : R
ha : (aeval a) p = 0
⊢ ∀ (s₁ s₂ : R), Commute ((algebraMap R A) s₁) ((algebraMap R A) s₂)
tactic: rw [aeval_def, scaleRoots_eval₂_mul_of_commute, ← aeval_def, ha, mul_zero]
Theorem: Profinite.NobelingProof.continuous_proj
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
⊢ Continuous (Proj J)
state_after: I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
⊢ Continuous fun c i => if J i then c i else false
tactic: dsimp (config := { unfoldPartialApp := true }) [Proj]
state_before: I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
⊢ Continuous fun c i => if J i then c i else false
state_after: case h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
⊢ ∀ (i : I), Continuous fun a => if J i then a i else false
tactic: apply continuous_pi
state_before: case h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
⊢ ∀ (i : I), Continuous fun a => if J i then a i else false
state_after: case h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
i : I
⊢ Continuous fun a => if J i then a i else false
tactic: intro i
state_before: case h
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
i : I
⊢ Continuous fun a => if J i then a i else false
state_after: case h.isTrue
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
i : I
h✝ : J i
⊢ Continuous fun a => a i

case h.isFalse
I : Type u
inst✝⁴ : LinearOrder I
inst✝³ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
J K L : I → Prop
inst✝² : (i : I) → Decidable (J i)
inst✝¹ : (i : I) → Decidable (K i)
inst✝ : (i : I) → Decidable (L i)
i : I
h✝ : ¬J i
⊢ Continuous fun a => false
tactic: split
Theorem: MeasureTheory.Measure.IsCondKernel.apply_of_ne_zero
File: Mathlib/Probability/Kernel/Disintegration/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mΩ : MeasurableSpace Ω
ρ : Measure (α × Ω)
inst✝² : IsFiniteMeasure ρ
ρCond : Kernel α Ω
inst✝¹ : ρ.IsCondKernel ρCond
inst✝ : MeasurableSingletonClass α
x : α
hx : ρ.fst {x} ≠ 0
s : Set Ω
⊢ (ρCond x) s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mΩ : MeasurableSpace Ω
ρ : Measure (α × Ω)
inst✝² : IsFiniteMeasure ρ
ρCond : Kernel α Ω
inst✝¹ : ρ.IsCondKernel ρCond
inst✝ : MeasurableSingletonClass α
x : α
hx : ρ.fst {x} ≠ 0
s : Set Ω
this : (ρCond x) s = (comap (fun y => (x, y)) ((ρ.fst {x})⁻¹ • ρ)) s
⊢ (ρCond x) s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)
tactic: have : ρCond x s = ((ρ.fst {x})⁻¹ • ρ).comap (fun (y : Ω) ↦ (x, y)) s := by
    congr 2 with s hs
    simp [IsCondKernel.apply_of_ne_zero_of_measurableSet _ _ hx hs,
      (measurableEmbedding_prod_mk_left x).comap_apply]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mΩ : MeasurableSpace Ω
ρ : Measure (α × Ω)
inst✝² : IsFiniteMeasure ρ
ρCond : Kernel α Ω
inst✝¹ : ρ.IsCondKernel ρCond
inst✝ : MeasurableSingletonClass α
x : α
hx : ρ.fst {x} ≠ 0
s : Set Ω
this : (ρCond x) s = (comap (fun y => (x, y)) ((ρ.fst {x})⁻¹ • ρ)) s
⊢ (ρCond x) s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)
state_after: no goals
tactic: simp [this, (measurableEmbedding_prod_mk_left x).comap_apply, hx]
Theorem: CauSeq.inf_equiv_inf
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
⊢ a₁ ⊓ b₁ ≈ a₂ ⊓ b₂
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
⊢ ∃ i, ∀ j ≥ i, |↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j| < ε
tactic: intro ε ε0
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
⊢ ∃ i, ∀ j ≥ i, |↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j| < ε
state_after: case intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ j ≥ ai, |↑(a₁ - a₂) j| < ε
⊢ ∃ i, ∀ j ≥ i, |↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j| < ε
tactic: obtain ⟨ai, hai⟩ := ha ε ε0
state_before: case intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ j ≥ ai, |↑(a₁ - a₂) j| < ε
⊢ ∃ i, ∀ j ≥ i, |↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j| < ε
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ j ≥ ai, |↑(a₁ - a₂) j| < ε
bi : ℕ
hbi : ∀ j ≥ bi, |↑(b₁ - b₂) j| < ε
⊢ ∃ i, ∀ j ≥ i, |↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j| < ε
tactic: obtain ⟨bi, hbi⟩ := hb ε ε0
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ j ≥ ai, |↑(a₁ - a₂) j| < ε
bi : ℕ
hbi : ∀ j ≥ bi, |↑(b₁ - b₂) j| < ε
⊢ ∃ i, ∀ j ≥ i, |↑(a₁ ⊓ b₁ - a₂ ⊓ b₂) j| < ε
state_after: no goals
tactic: exact
    ⟨ai ⊔ bi, fun i hi =>
      (abs_min_sub_min_le_max (a₁ i) (b₁ i) (a₂ i) (b₂ i)).trans_lt
        (max_lt (hai i (sup_le_iff.mp hi).1) (hbi i (sup_le_iff.mp hi).2))⟩
Theorem: CategoryTheory.Comma.post_obj_left
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.158446, u_1} A'
inst✝³ : Category.{?u.158450, u_2} B'
inst✝² : Category.{?u.158454, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
L : A ⥤ T
R : B ⥤ T
F : T ⥤ C
X✝ Y✝ : Comma L R
f : X✝ ⟶ Y✝
⊢ (L ⋙ F).map f.left ≫ ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) Y✝).hom =
    ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) X✝).hom ≫ (R ⋙ F).map f.right
state_after: no goals
tactic: simp only [Functor.comp_map, ← F.map_comp, f.w]
Theorem: Fin.predAbove_castPred_of_lt
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p i : Fin (n + 1)
h : p < i
hp : optParam (p ≠ last n) ⋯
hi : optParam (i ≠ 0) ⋯
⊢ (p.castPred hp).predAbove i = i.pred hi
state_after: no goals
tactic: rw [predAbove_of_castSucc_lt _ _ (castSucc_castPred _ _ ▸ h)]
Theorem: List.formPerm_eq_one_iff
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
hl : l.Nodup
⊢ l.formPerm = 1 ↔ l.length ≤ 1
state_after: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x : α
hl : [].Nodup
⊢ [].formPerm = 1 ↔ [].length ≤ 1

case cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
x hd : α
tl : List α
hl : (hd :: tl).Nodup
⊢ (hd :: tl).formPerm = 1 ↔ (hd :: tl).length ≤ 1
tactic: cases' l with hd tl
Theorem: Finset.codisjoint_left
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
s t : Finset α
⊢ Codisjoint s t ↔ ∀ ⦃a : α⦄, a ∉ s → a ∈ t
state_after: no goals
tactic: classical simp [codisjoint_iff, eq_univ_iff_forall, or_iff_not_imp_left]
Theorem: inducing_sigma_map
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
κ : Type u_6
σ : ι → Type u_7
τ : κ → Type u_8
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace X
f₁ : ι → κ
f₂ : (i : ι) → σ i → τ (f₁ i)
h₁ : Injective f₁
⊢ Inducing (Sigma.map f₁ f₂) ↔ ∀ (i : ι), Inducing (f₂ i)
state_after: no goals
tactic: simp only [inducing_iff_nhds, Sigma.forall, Sigma.nhds_mk, Sigma.map_mk, ← map_sigma_mk_comap h₁,
    map_inj sigma_mk_injective]
Theorem: Int.map_ceil
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : LinearOrderedRing α
inst✝⁴ : LinearOrderedRing β
inst✝³ : FloorRing α
inst✝² : FloorRing β
inst✝¹ : FunLike F α β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ⇑f
a : α
n : ℤ
⊢ f a ≤ ↑n ↔ a ≤ ↑n
state_after: no goals
tactic: rw [← map_intCast f, hf.le_iff_le]
Theorem: MeasureTheory.weightedSMul_zero_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
⊢ weightedSMul 0 = 0
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
x✝ : Set α
⊢ weightedSMul 0 x✝ = 0 x✝
tactic: ext1
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
x✝ : Set α
⊢ weightedSMul 0 x✝ = 0 x✝
state_after: no goals
tactic: simp [weightedSMul]
Theorem: PNat.XgcdType.reduce_a
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: u✝ u : XgcdType
h : u.r = 0
⊢ u.reduce = u.finish
state_after: u✝ u : XgcdType
h : u.r = 0
⊢ (if x : u.r = 0 then u.finish else u.step.reduce.flip) = u.finish
tactic: rw [reduce]
state_before: u✝ u : XgcdType
h : u.r = 0
⊢ (if x : u.r = 0 then u.finish else u.step.reduce.flip) = u.finish
state_after: no goals
tactic: exact if_pos h
Theorem: Fin.castSucc_lt_or_lt_succ
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ i.castSucc < p ∨ p < i.succ
state_after: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑i < ↑p ∨ ↑p < ↑i + 1
tactic: simp [Fin.lt_def, -val_fin_lt]
state_before: n m : ℕ
p : Fin (n + 1)
i : Fin n
⊢ ↑i < ↑p ∨ ↑p < ↑i + 1
state_after: no goals
tactic: omega
Theorem: List.pairwise_of_coe_toFinset_pairwise
File: Mathlib/Data/Finset/Pairwise.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
ι' : Type u_3
β : Type u_4
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : (↑l.toFinset).Pairwise r
hn : l.Nodup
⊢ Pairwise r l
state_after: α : Type u_1
ι : Type u_2
ι' : Type u_3
β : Type u_4
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : {a | a ∈ l}.Pairwise r
hn : l.Nodup
⊢ Pairwise r l
tactic: rw [coe_toFinset] at hl
state_before: α : Type u_1
ι : Type u_2
ι' : Type u_3
β : Type u_4
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : {a | a ∈ l}.Pairwise r
hn : l.Nodup
⊢ Pairwise r l
state_after: no goals
tactic: exact hn.pairwise_of_set_pairwise hl
Theorem: Complex.div_natCast_re
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
n : ℕ
⊢ (z / ↑n).re = z.re / ↑n
state_after: no goals
tactic: rw [div_natCast]
Theorem: Polynomial.degree_cubic_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
⊢ (C a * X ^ 3 + C b * X ^ 2 + C c * X + C d).degree ≤ 3
state_after: no goals
tactic: simpa only [add_assoc] using
    degree_add_le_of_degree_le (degree_C_mul_X_pow_le 3 a)
      (le_trans degree_quadratic_le <| WithBot.coe_le_coe.mpr <| Nat.le_succ 2)
Theorem: ContinuousLinearEquiv.contDiffWithinAt_comp_iff
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n (f ∘ ⇑e) (⇑e ⁻¹' s) (e.symm x) ↔ ContDiffWithinAt 𝕜 n f s x
state_after: case mp
𝕜 : 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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n (f ∘ ⇑e) (⇑e ⁻¹' s) (e.symm x) → ContDiffWithinAt 𝕜 n f s x

case mpr
𝕜 : 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
e : G ≃L[𝕜] E
⊢ ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n (f ∘ ⇑e) (⇑e ⁻¹' s) (e.symm x)
tactic: constructor
Theorem: WeierstrassCurve.Ψ_neg
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
n : ℤ
⊢ W.Ψ (-n) = -W.Ψ n
state_after: no goals
tactic: simp only [Ψ, preΨ_neg, C_neg, neg_mul (α := R[X][Y]), even_neg]
Theorem: ne_zero_of_irreducible_X_pow_sub_C
File: Mathlib/FieldTheory/KummerExtension.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
n : ℕ
a : K
H : Irreducible (X ^ n - C a)
⊢ n ≠ 0
state_after: K : Type u
inst✝ : Field K
a : K
H : Irreducible (X ^ 0 - C a)
⊢ False
tactic: rintro rfl
state_before: K : Type u
inst✝ : Field K
a : K
H : Irreducible (X ^ 0 - C a)
⊢ False
state_after: K : Type u
inst✝ : Field K
a : K
H : Irreducible (C (1 - a))
⊢ False
tactic: rw [pow_zero, ← C.map_one, ← map_sub] at H
state_before: K : Type u
inst✝ : Field K
a : K
H : Irreducible (C (1 - a))
⊢ False
state_after: no goals
tactic: exact not_irreducible_C _ H
Theorem: CauchyFilter.mem_uniformity'
File: Mathlib/Topology/UniformSpace/Completion.lean

Proof steps:
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set (CauchyFilter α × CauchyFilter α)
⊢ s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s
state_after: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set (CauchyFilter α × CauchyFilter α)
t : Set (α × α)
_h : t ∈ 𝓤 α
⊢ gen t ⊆ s ↔ ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s
tactic: refine mem_uniformity.trans (exists_congr (fun t => and_congr_right_iff.mpr (fun _h => ?_)))
state_before: α : Type u
inst✝² : UniformSpace α
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set (CauchyFilter α × CauchyFilter α)
t : Set (α × α)
_h : t ∈ 𝓤 α
⊢ gen t ⊆ s ↔ ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s
state_after: no goals
tactic: exact ⟨fun h _f _g ht => h ht, fun h _p hp => h _ _ hp⟩
Theorem: differentiableWithinAt_add_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
h : DifferentiableWithinAt 𝕜 (fun y => f y + c) s x
⊢ DifferentiableWithinAt 𝕜 f s x
state_after: no goals
tactic: simpa using h.add_const (-c)
Theorem: Mon_.trivial_one
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ (λ_ (𝟙_ C)).hom ▷ 𝟙_ C ≫ (λ_ (𝟙_ C)).hom = (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom ≫ 𝟙_ C ◁ (λ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom
state_after: no goals
tactic: coherence
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ 𝟙_ C ◁ 𝟙 (𝟙_ C) ≫ (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom
state_after: no goals
tactic: coherence
Theorem: mem_ball_zero_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
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 ∈ ball 1 r ↔ ‖a‖ < r
state_after: no goals
tactic: rw [mem_ball, dist_one_right]
Theorem: Matrix.add_cons
File: Mathlib/Algebra/Group/Fin/Tuple.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
n : ℕ
inst✝ : Add α
v : Fin n.succ → α
y : α
w : Fin n → α
⊢ v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w)
state_after: case h
α : Type u_1
M : Type u_2
n : ℕ
inst✝ : Add α
v : Fin n.succ → α
y : α
w : Fin n → α
i : Fin n.succ
⊢ (v + vecCons y w) i = vecCons (vecHead v + y) (vecTail v + w) i
tactic: ext i
state_before: case h
α : Type u_1
M : Type u_2
n : ℕ
inst✝ : Add α
v : Fin n.succ → α
y : α
w : Fin n → α
i : Fin n.succ
⊢ (v + vecCons y w) i = vecCons (vecHead v + y) (vecTail v + w) i
state_after: no goals
tactic: refine i.cases ?_ ?_ <;> simp [vecHead, vecTail]
Theorem: ComplexShape.embeddingUpIntLE_f
File: Mathlib/Algebra/Homology/Embedding/Basic.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
p : ℤ
x✝¹ x✝ : ℕ
h : (fun n => p - ↑n) x✝¹ = (fun n => p - ↑n) x✝
⊢ x✝¹ = x✝
state_after: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
p : ℤ
x✝¹ x✝ : ℕ
h : p - ↑x✝¹ = p - ↑x✝
⊢ x✝¹ = x✝
tactic: dsimp at h
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
p : ℤ
x✝¹ x✝ : ℕ
h : p - ↑x✝¹ = p - ↑x✝
⊢ x✝¹ = x✝
state_after: no goals
tactic: omega
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
p : ℤ
⊢ ∀ (i₁ i₂ : ℕ), (down ℕ).Rel i₁ i₂ ↔ (up ℤ).Rel ((fun n => p - ↑n) i₁) ((fun n => p - ↑n) i₂)
state_after: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
p : ℤ
⊢ ∀ (i₁ i₂ : ℕ), i₂ + 1 = i₁ ↔ p - ↑i₁ + 1 = p - ↑i₂
tactic: dsimp
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
p : ℤ
⊢ ∀ (i₁ i₂ : ℕ), i₂ + 1 = i₁ ↔ p - ↑i₁ + 1 = p - ↑i₂
state_after: no goals
tactic: omega
Theorem: log_le_harmonic_floor
File: Mathlib/NumberTheory/Harmonic/Bounds.lean

Proof steps:
state_before: y : ℝ
hy : 0 ≤ y
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)
state_after: case pos
y : ℝ
hy : 0 ≤ y
h0 : y = 0
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)

case neg
y : ℝ
hy : 0 ≤ y
h0 : ¬y = 0
⊢ Real.log y ≤ ↑(harmonic ⌊y⌋₊)
tactic: by_cases h0 : y = 0