ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.Gamma_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: ⊢ Gamma 0 = 0
state_after: no goals
tactic: simpa only [← Complex.ofReal_zero, Complex.Gamma_ofReal, Complex.ofReal_inj] using
    Complex.Gamma_zero
Theorem: AddAction.nsmul_vadd_eq_iff_period_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
n : ℕ
m : M
a : α
⊢ m ^ n • a = a ↔ period m a ∣ n
state_after: no goals
tactic: rw [period_eq_minimalPeriod, ← isPeriodicPt_iff_minimalPeriod_dvd, isPeriodicPt_smul_iff]
Theorem: Complex.frontier_setOf_im_le
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: a : ℝ
⊢ frontier {z | z.im ≤ a} = {z | z.im = a}
state_after: no goals
tactic: simpa only [frontier_Iic] using frontier_preimage_im (Iic a)
Theorem: mul_right_inv
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a✝ b c a : G
⊢ a * a⁻¹ = 1
state_after: no goals
tactic: rw [← mul_left_inv a⁻¹, inv_eq_of_mul (mul_left_inv a)]
Theorem: rank_add_rank_le_rank_prod
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁸ : Ring R
inst✝⁷ : CommRing S
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M₁
inst✝ : Nontrivial R
⊢ Module.rank R M + Module.rank R M₁ ≤ Module.rank R (M × M₁)
state_after: no goals
tactic: convert ← lift_rank_add_lift_rank_le_rank_prod R M M₁ <;> apply lift_id
Theorem: PadicSeq.norm_nonneg
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : f ≈ 0
⊢ 0 ≤ f.norm
state_after: no goals
tactic: simp [hf, norm]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f : PadicSeq p
hf : ¬f ≈ 0
⊢ 0 ≤ f.norm
state_after: no goals
tactic: simp [norm, hf, padicNorm.nonneg]
Theorem: MvPolynomial.isHomogeneous_C
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
r : R
⊢ (C r).IsHomogeneous 0
state_after: case hn
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
r : R
⊢ Finsupp.degree 0 = 0
tactic: apply isHomogeneous_monomial
state_before: case hn
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
r : R
⊢ Finsupp.degree 0 = 0
state_after: no goals
tactic: simp only [Finsupp.degree, Finsupp.zero_apply, Finset.sum_const_zero]
Theorem: Polynomial.degree_map_eq_of_leadingCoeff_ne_zero
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
⊢ p.degree ≤ (map f p).degree
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ p.degree ≤ (map f p).degree
tactic: have hp0 : p ≠ 0 :=
      leadingCoeff_ne_zero.mp fun hp0 => hf (_root_.trans (congr_arg _ hp0) f.map_zero)
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ p.degree ≤ (map f p).degree
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ ↑p.natDegree ≤ (map f p).degree
tactic: rw [degree_eq_natDegree hp0]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ ↑p.natDegree ≤ (map f p).degree
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ (map f p).coeff p.natDegree ≠ 0
tactic: refine le_degree_of_ne_zero ?_
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ (map f p).coeff p.natDegree ≠ 0
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ f (p.coeff p.natDegree) ≠ 0
tactic: rw [coeff_map]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : f p.leadingCoeff ≠ 0
hp0 : p ≠ 0
⊢ f (p.coeff p.natDegree) ≠ 0
state_after: no goals
tactic: exact hf
Theorem: CategoryTheory.ChosenFiniteProducts.associator_inv_fst_snd
File: Mathlib/CategoryTheory/ChosenFiniteProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ (α_ X Y Z).inv ≫ fst (X ⊗ Y) Z ≫ snd X Y = snd X (Y ⊗ Z) ≫ fst Y Z
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ Limits.BinaryFan.snd (product X (product Y Z).cone.pt).cone ≫ Limits.BinaryFan.fst (product Y Z).cone =
    snd X (Y ⊗ Z) ≫ fst Y Z
tactic: erw [lift_fst_assoc, lift_snd]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ Limits.BinaryFan.snd (product X (product Y Z).cone.pt).cone ≫ Limits.BinaryFan.fst (product Y Z).cone =
    snd X (Y ⊗ Z) ≫ fst Y Z
state_after: no goals
tactic: rfl
Theorem: Filter.Frequently.and_eventually
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
hq : ∀ᶠ (x : α) in f, q x
⊢ ∃ᶠ (x : α) in f, p x ∧ q x
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
hq : ∀ᶠ (x : α) in f, q x
h : ∀ᶠ (x : α) in f, ¬(fun x => p x ∧ q x) x
⊢ ∀ (x : α), ¬(fun x => p x ∧ q x) x → q x → ¬(fun x => p x) x
tactic: refine mt (fun h => hq.mp <| h.mono ?_) hp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∃ᶠ (x : α) in f, p x
hq : ∀ᶠ (x : α) in f, q x
h : ∀ᶠ (x : α) in f, ¬(fun x => p x ∧ q x) x
⊢ ∀ (x : α), ¬(fun x => p x ∧ q x) x → q x → ¬(fun x => p x) x
state_after: no goals
tactic: exact fun x hpq hq hp => hpq ⟨hp, hq⟩
Theorem: TopCat.Sheaf.hom_ext
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app (op (B i)) = β.app (op (B i))
⊢ α = β
state_after: case a
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app (op (B i)) = β.app (op (B i))
⊢ (restrictHomEquivHom F F' h).symm α = (restrictHomEquivHom F F' h).symm β
tactic: apply (restrictHomEquivHom F F' h).symm.injective
state_before: case a
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app (op (B i)) = β.app (op (B i))
⊢ (restrictHomEquivHom F F' h).symm α = (restrictHomEquivHom F F' h).symm β
state_after: case a.w.h
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app (op (B i)) = β.app (op (B i))
i : (InducedCategory (Opens ↑X) B)ᵒᵖ
⊢ ((restrictHomEquivHom F F' h).symm α).app i = ((restrictHomEquivHom F F' h).symm β).app i
tactic: ext i
state_before: case a.w.h
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
ι : Type u_1
B : ι → Opens ↑X
F : Presheaf C X
F' : Sheaf C X
h : Opens.IsBasis (Set.range B)
α β : F ⟶ F'.val
he : ∀ (i : ι), α.app (op (B i)) = β.app (op (B i))
i : (InducedCategory (Opens ↑X) B)ᵒᵖ
⊢ ((restrictHomEquivHom F F' h).symm α).app i = ((restrictHomEquivHom F F' h).symm β).app i
state_after: no goals
tactic: exact he i.unop
Theorem: SimpleGraph.two_mul_card_edgeFinset
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype (Sym2 V)
⊢ 2 * G.edgeFinset.card =
    (filter
        (fun x =>
          match x with
          | (x, y) => G.Adj x y)
        univ).card
state_after: V : Type u
G : SimpleGraph V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype (Sym2 V)
⊢ univ.card =
    (filter
        (fun x =>
          match x with
          | (x, y) => G.Adj x y)
        univ).card
tactic: rw [← dart_card_eq_twice_card_edges, ← card_univ]
state_before: V : Type u
G : SimpleGraph V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype (Sym2 V)
⊢ univ.card =
    (filter
        (fun x =>
          match x with
          | (x, y) => G.Adj x y)
        univ).card
state_after: no goals
tactic: refine card_bij' (fun d _ ↦ (d.fst, d.snd)) (fun xy h ↦ ⟨xy, (mem_filter.1 h).2⟩) ?_ ?_ ?_ ?_
    <;> simp
Theorem: rank_le_of_injective_injective
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : R' → R
j : M →+ M₁
hi : ∀ (r : R'), i r = 0 → r = 0
hj : Injective ⇑j
hc : ∀ (r : R') (m : M), j (i r • m) = r • j m
⊢ Module.rank R M ≤ Module.rank R' M₁
state_after: no goals
tactic: simpa only [lift_id] using lift_rank_le_of_injective_injective i j hi hj hc
Theorem: Set.pairwise_disjoint_Ico_zsmul
File: Mathlib/Algebra/Order/Interval/Set/Group.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
a b : α
⊢ Pairwise (Disjoint on fun n => Ico (b ^ n) (b ^ (n + 1)))
state_after: no goals
tactic: simpa only [one_mul] using pairwise_disjoint_Ico_mul_zpow 1 b
Theorem: CategoryTheory.obj_μ_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((F.μ m₁ m₂).app X) =
    (F.μ m₂ m₃).app ((F.obj m₁).obj X) ≫
      (F.μ m₁ (m₂ ⊗ m₃)).app X ≫ (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (F.μIso (m₁ ⊗ m₂) m₃).inv.app X
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((F.μ m₁ m₂).app X) =
    (F.obj m₃).map ((F.μ m₁ m₂).app X) ≫
      (F.μ (m₁ ⊗ m₂) m₃).app X ≫
        (F.map (α_ m₁ m₂ m₃).hom).app X ≫ (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (F.μIso (m₁ ⊗ m₂) m₃).inv.app X
tactic: rw [← associativity_app_assoc]
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ m₃ : M
X : C
⊢ (F.obj m₃).map ((F.μ m₁ m₂).app X) =
    (F.obj m₃).map ((F.μ m₁ m₂).app X) ≫
      (F.μ (m₁ ⊗ m₂) m₃).app X ≫
        (F.map (α_ m₁ m₂ m₃).hom).app X ≫ (F.map (α_ m₁ m₂ m₃).inv).app X ≫ (F.μIso (m₁ ⊗ m₂) m₃).inv.app X
state_after: no goals
tactic: simp
Theorem: TrivSqZeroExt.map_inr
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: S : Type u_1
R R' : Type u
M : Type v
inst✝²⁶ : CommSemiring S
inst✝²⁵ : Semiring R
inst✝²⁴ : CommSemiring R'
inst✝²³ : AddCommMonoid M
inst✝²² : Algebra S R
inst✝²¹ : Algebra S R'
inst✝²⁰ : Module S M
inst✝¹⁹ : Module R M
inst✝¹⁸ : Module Rᵐᵒᵖ M
inst✝¹⁷ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁶ : IsScalarTower S R M
inst✝¹⁵ : IsScalarTower S Rᵐᵒᵖ M
inst✝¹⁴ : Module R' M
inst✝¹³ : Module R'ᵐᵒᵖ M
inst✝¹² : IsCentralScalar R' M
inst✝¹¹ : IsScalarTower S R' M
A : Type u_2
inst✝¹⁰ : Semiring A
inst✝⁹ : Algebra S A
inst✝⁸ : Algebra R' A
N : Type u_3
P : Type u_4
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R' N
inst✝⁵ : Module R'ᵐᵒᵖ N
inst✝⁴ : IsCentralScalar R' N
inst✝³ : AddCommMonoid P
inst✝² : Module R' P
inst✝¹ : Module R'ᵐᵒᵖ P
inst✝ : IsCentralScalar R' P
f : M →ₗ[R'] N
x : M
⊢ (map f) (inr x) = inr (f x)
state_after: no goals
tactic: rw [map, liftEquivOfComm_apply, lift_apply_inr, LinearMap.comp_apply, inrHom_apply]
Theorem: Int.neg_pred
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b c d m n a : ℤ
⊢ -a.pred = (-a).succ
state_after: no goals
tactic: rw [← Int.neg_eq_comm.mp (neg_succ (-a)), Int.neg_neg]
Theorem: quadratic_eq_zero_iff_of_discrim_eq_zero
File: Mathlib/Algebra/QuadraticDiscriminant.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
this : discrim a b c = 0 * 0
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)
tactic: have : discrim a b c = 0 * 0 := by rw [h, mul_zero]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x✝ : K
ha : a ≠ 0
h : discrim a b c = 0
x : K
this : discrim a b c = 0 * 0
⊢ a * x * x + b * x + c = 0 ↔ x = -b / (2 * a)
state_after: no goals
tactic: rw [quadratic_eq_zero_iff ha this, add_zero, sub_zero, or_self_iff]
Theorem: HomologicalComplex.opcyclesMap_comp
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
⊢ opcyclesMap (φ ≫ ψ) i = opcyclesMap φ i ≫ opcyclesMap ψ i
state_after: C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
⊢ ShortComplex.opcyclesMap ((shortComplexFunctor C c i).map (φ ≫ ψ)) =
    ShortComplex.opcyclesMap ((shortComplexFunctor C c i).map φ) ≫
      ShortComplex.opcyclesMap ((shortComplexFunctor C c i).map ψ)
tactic: dsimp [opcyclesMap]
state_before: C : Type u_1
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K L M : HomologicalComplex C c
φ : K ⟶ L
ψ : L ⟶ M
i j k : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
⊢ ShortComplex.opcyclesMap ((shortComplexFunctor C c i).map (φ ≫ ψ)) =
    ShortComplex.opcyclesMap ((shortComplexFunctor C c i).map φ) ≫
      ShortComplex.opcyclesMap ((shortComplexFunctor C c i).map ψ)
state_after: no goals
tactic: rw [Functor.map_comp, ShortComplex.opcyclesMap_comp]
Theorem: Set.ncard_eq_toFinset_card'
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t s : Set α
inst✝ : Fintype ↑s
⊢ s.ncard = s.toFinset.card
state_after: no goals
tactic: simp [← Nat.card_coe_set_eq, Nat.card_eq_fintype_card]
Theorem: Seminorm.ball_smul_ball
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ p : Seminorm 𝕜 E
r₁ r₂ : ℝ
⊢ Metric.ball 0 r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂)
state_after: case inl
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ p : Seminorm 𝕜 E
r₁ : ℝ
⊢ Metric.ball 0 r₁ • p.ball 0 0 ⊆ p.ball 0 (r₁ * 0)

case inr
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ p : Seminorm 𝕜 E
r₁ r₂ : ℝ
hr₂ : r₂ ≠ 0
⊢ Metric.ball 0 r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂)
tactic: rcases eq_or_ne r₂ 0 with rfl | hr₂
Theorem: Complex.Gammaℝ_residue_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

Proof steps:
state_before: ⊢ Tendsto (fun s => s * s.Gammaℝ) (𝓝[≠] 0) (𝓝 2)
state_after: h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
⊢ Tendsto (fun s => s * s.Gammaℝ) (𝓝[≠] 0) (𝓝 2)
tactic: have h : Tendsto (fun z : ℂ ↦ z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1) := by
    refine tendsto_self_mul_Gamma_nhds_zero.comp ?_
    rw [tendsto_nhdsWithin_iff, (by simp : 𝓝 (0 : ℂ) = 𝓝 (0 / 2))]
    exact ⟨(tendsto_id.div_const _).mono_left nhdsWithin_le_nhds,
      eventually_of_mem self_mem_nhdsWithin fun x hx ↦ div_ne_zero hx two_ne_zero⟩
state_before: h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
⊢ Tendsto (fun s => s * s.Gammaℝ) (𝓝[≠] 0) (𝓝 2)
state_after: h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
h' : Tendsto (fun s => 2 * ↑π ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2)
⊢ Tendsto (fun s => s * s.Gammaℝ) (𝓝[≠] 0) (𝓝 2)
tactic: have h' : Tendsto (fun s : ℂ ↦ 2 * (π : ℂ) ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2) := by
    rw [(by simp : 𝓝 2 = 𝓝 (2 * (π : ℂ) ^ (-(0 : ℂ) / 2)))]
    refine Tendsto.mono_left (ContinuousAt.tendsto ?_) nhdsWithin_le_nhds
    exact continuousAt_const.mul ((continuousAt_const_cpow (ofReal_ne_zero.mpr pi_ne_zero)).comp
      (continuousAt_id.neg.div_const _))
state_before: h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
h' : Tendsto (fun s => 2 * ↑π ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2)
⊢ Tendsto (fun s => s * s.Gammaℝ) (𝓝[≠] 0) (𝓝 2)
state_after: case h.e'_3.h
h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
h' : Tendsto (fun s => 2 * ↑π ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2)
z : ℂ
⊢ z * z.Gammaℝ = 2 * ↑π ^ (-z / 2) * (z / 2 * Gamma (z / 2))
tactic: convert mul_one (2 : ℂ) ▸ (h'.mul h) using 2 with z
state_before: case h.e'_3.h
h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
h' : Tendsto (fun s => 2 * ↑π ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2)
z : ℂ
⊢ z * z.Gammaℝ = 2 * ↑π ^ (-z / 2) * (z / 2 * Gamma (z / 2))
state_after: case h.e'_3.h
h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
h' : Tendsto (fun s => 2 * ↑π ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2)
z : ℂ
⊢ z * (↑π ^ (-z / 2) * Gamma (z / 2)) = 2 * ↑π ^ (-z / 2) * (z / 2 * Gamma (z / 2))
tactic: rw [Gammaℝ]
state_before: case h.e'_3.h
h : Tendsto (fun z => z / 2 * Gamma (z / 2)) (𝓝[≠] 0) (𝓝 1)
h' : Tendsto (fun s => 2 * ↑π ^ (-s / 2)) (𝓝[≠] 0) (𝓝 2)
z : ℂ
⊢ z * (↑π ^ (-z / 2) * Gamma (z / 2)) = 2 * ↑π ^ (-z / 2) * (z / 2 * Gamma (z / 2))
state_after: no goals
tactic: ring_nf
Theorem: GaloisConnection.isLUB_l_image
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
s : Set α
a : α
h : IsLUB s a
b : β
hb : b ∈ upperBounds (l '' s)
⊢ u b ∈ upperBounds s
state_after: no goals
tactic: rwa [gc.upperBounds_l_image] at hb
Theorem: List.eraseIdx_insertNth
File: Mathlib/Data/List/InsertNth.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
l : List α
⊢ (insertNth n a l).eraseIdx n = l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
l : List α
⊢ modifyNthTail (tail ∘ cons a) n l = l
tactic: rw [eraseIdx_eq_modifyNthTail, insertNth, modifyNthTail_modifyNthTail_same]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
l : List α
⊢ modifyNthTail (tail ∘ cons a) n l = l
state_after: no goals
tactic: exact modifyNthTail_id _ _
Theorem: Nat.Squarefree.ext_iff
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m✝ n✝ p n m : ℕ
hn : Squarefree n
hm : Squarefree m
⊢ n = m ↔ ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
state_after: s : Finset ℕ
m✝ n✝ p✝ n m : ℕ
hn : Squarefree n
hm : Squarefree m
h : ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
p : ℕ
⊢ n.factorization p = m.factorization p
tactic: refine ⟨by rintro rfl; simp, fun h => eq_of_factorization_eq hn.ne_zero hm.ne_zero fun p => ?_⟩
state_before: s : Finset ℕ
m✝ n✝ p✝ n m : ℕ
hn : Squarefree n
hm : Squarefree m
h : ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
p : ℕ
⊢ n.factorization p = m.factorization p
state_after: case pos
s : Finset ℕ
m✝ n✝ p✝ n m : ℕ
hn : Squarefree n
hm : Squarefree m
h : ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
p : ℕ
hp : Prime p
⊢ n.factorization p = m.factorization p

case neg
s : Finset ℕ
m✝ n✝ p✝ n m : ℕ
hn : Squarefree n
hm : Squarefree m
h : ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
p : ℕ
hp : ¬Prime p
⊢ n.factorization p = m.factorization p
tactic: by_cases hp : p.Prime
state_before: case neg
s : Finset ℕ
m✝ n✝ p✝ n m : ℕ
hn : Squarefree n
hm : Squarefree m
h : ∀ (p : ℕ), Prime p → (p ∣ n ↔ p ∣ m)
p : ℕ
hp : ¬Prime p
⊢ n.factorization p = m.factorization p
state_after: no goals
tactic: rw [factorization_eq_zero_of_non_prime _ hp, factorization_eq_zero_of_non_prime _ hp]
Theorem: Finsupp.single_apply_mem
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
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
x : α
⊢ (single a b) x ∈ {0, b}
state_after: no goals
tactic: rcases em (a = x) with (rfl | hx) <;> [simp; simp [single_eq_of_ne hx]]
Theorem: Nat.base_pow_length_digits_le
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b m : ℕ
hb : 1 < b
⊢ m ≠ 0 → b ^ (b.digits m).length ≤ b * m
state_after: case succ.succ
n m b : ℕ
⊢ ¬m = 0 → (b + 1 + 1) ^ ((b + 1 + 1).digits m).length ≤ (b + 1 + 1) * m
tactic: rcases b with (_ | _ | b) <;> try simp_all
state_before: case succ.succ
n m b : ℕ
⊢ ¬m = 0 → (b + 1 + 1) ^ ((b + 1 + 1).digits m).length ≤ (b + 1 + 1) * m
state_after: no goals
tactic: exact base_pow_length_digits_le' b m
Theorem: AlgebraicGeometry.ProjIsoSpecTopComponent.toSpec.image_basicOpen_eq_basicOpen
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ f ^ i ∈ 𝒜 (m * i)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ f ^ i ∈ 𝒜 (i * m)
tactic: rw [mul_comm]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ f ^ i ∈ 𝒜 (i * m)
state_after: no goals
tactic: exact SetLike.pow_mem_graded _ f_deg
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ Subtype.val ⁻¹' ↑(pbo ↑(((decompose 𝒜) a) i)) =
    ⇑(toSpec 𝒜 f) ⁻¹'
      (sbo
          HomogeneousLocalization.mk
            { deg := m * i, num := ⟨↑(((decompose 𝒜) a) i) ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ }).carrier
state_after: no goals
tactic: rw [Opens.carrier_eq_coe, toSpec_preimage_basicOpen, ProjectiveSpectrum.basicOpen_pow 𝒜 _ m hm]