ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: sigmaFinsuppEquivDFinsupp_support
File: Mathlib/Data/Finsupp/ToDFinsupp.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
⊢ (sigmaFinsuppEquivDFinsupp f).support = f.splitSupport
state_after: case a
ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
a✝ : ι
⊢ a✝ ∈ (sigmaFinsuppEquivDFinsupp f).support ↔ a✝ ∈ f.splitSupport
tactic: ext
state_before: case a
ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
a✝ : ι
⊢ a✝ ∈ (sigmaFinsuppEquivDFinsupp f).support ↔ a✝ ∈ f.splitSupport
state_after: case a
ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
a✝ : ι
⊢ (sigmaFinsuppEquivDFinsupp f) a✝ ≠ 0 ↔ a✝ ∈ f.splitSupport
tactic: rw [DFinsupp.mem_support_toFun]
state_before: case a
ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝³ : Semiring R
inst✝² : DecidableEq ι
inst✝¹ : Zero N
inst✝ : (i : ι) → (x : η i →₀ N) → Decidable (x ≠ 0)
f : (i : ι) × η i →₀ N
a✝ : ι
⊢ (sigmaFinsuppEquivDFinsupp f) a✝ ≠ 0 ↔ a✝ ∈ f.splitSupport
state_after: no goals
tactic: exact (Finsupp.mem_splitSupport_iff_nonzero _ _).symm
Theorem: Polynomial.monomial_left_inj
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a : R
ha : a ≠ 0
i j : ℕ
⊢ (monomial i) a = (monomial j) a ↔ i = j
state_after: no goals
tactic: simp only [← ofFinsupp_single, ofFinsupp.injEq, Finsupp.single_left_inj ha]
Theorem: MultilinearMap.domDomCongrLinearEquiv_symm_apply
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M₂
inst✝⁶ : Semiring S
inst✝⁵ : Module S M₂
inst✝⁴ : SMulCommClass R S M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
inst✝¹ : Module S M₃
inst✝ : SMulCommClass R S M₃
ι₁ : Type ?u.341072
ι₂ : Type ?u.341169
σ : ι₁ ≃ ι₂
c : S
f : MultilinearMap R (fun x => M₂) M₃
⊢ { toFun := __src✝.toFun, map_add' := ⋯ }.toFun (c • f) =
    (RingHom.id S) c • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun f
state_after: case H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M₂
inst✝⁶ : Semiring S
inst✝⁵ : Module S M₂
inst✝⁴ : SMulCommClass R S M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
inst✝¹ : Module S M₃
inst✝ : SMulCommClass R S M₃
ι₁ : Type ?u.341072
ι₂ : Type ?u.341169
σ : ι₁ ≃ ι₂
c : S
f : MultilinearMap R (fun x => M₂) M₃
x✝ : ι₂ → M₂
⊢ ({ toFun := __src✝.toFun, map_add' := ⋯ }.toFun (c • f)) x✝ =
    ((RingHom.id S) c • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun f) x✝
tactic: ext
state_before: case H
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹¹ : Semiring R
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : (i : ι) → Module R (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M₂
inst✝⁶ : Semiring S
inst✝⁵ : Module S M₂
inst✝⁴ : SMulCommClass R S M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
inst✝¹ : Module S M₃
inst✝ : SMulCommClass R S M₃
ι₁ : Type ?u.341072
ι₂ : Type ?u.341169
σ : ι₁ ≃ ι₂
c : S
f : MultilinearMap R (fun x => M₂) M₃
x✝ : ι₂ → M₂
⊢ ({ toFun := __src✝.toFun, map_add' := ⋯ }.toFun (c • f)) x✝ =
    ((RingHom.id S) c • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun f) x✝
state_after: no goals
tactic: simp [MultilinearMap.domDomCongr]
Theorem: CategoryTheory.shiftFunctorZero_hom_app_obj_of_induced
File: Mathlib/CategoryTheory/Shift/Induced.lean

Proof steps:
state_before: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
X : C
⊢ (shiftFunctorZero D A).hom.app (F.obj X) = (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X)
state_after: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
X : C
this : HasShift D A := HasShift.induced F A s i
⊢ (shiftFunctorZero D A).hom.app (F.obj X) = (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X)
tactic: letI := HasShift.induced F A s i
state_before: C : Type u_4
D : Type u_2
inst✝⁵ : Category.{u_5, u_4} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
X : C
this : HasShift D A := HasShift.induced F A s i
⊢ (shiftFunctorZero D A).hom.app (F.obj X) = (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X)
state_after: no goals
tactic: simp only [ShiftMkCore.shiftFunctorZero_eq, HasShift.Induced.zero_hom_app_obj]
Theorem: Lagrange.eval_basisDivisor_left_of_ne
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ eval x (basisDivisor x y) = 1
state_after: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ (x - y)⁻¹ * (x - y) = 1
tactic: simp only [basisDivisor, eval_mul, eval_C, eval_sub, eval_X]
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ (x - y)⁻¹ * (x - y) = 1
state_after: no goals
tactic: exact inv_mul_cancel (sub_ne_zero_of_ne hxy)
Theorem: RatFunc.intDegree_add_le
File: Mathlib/FieldTheory/RatFunc/Degree.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hy : y ≠ 0
hxy : x + y ≠ 0
⊢ (x + y).intDegree ≤ max x.intDegree y.intDegree
state_after: case pos
K : Type u
inst✝ : Field K
x y : RatFunc K
hy : y ≠ 0
hxy : x + y ≠ 0
hx : x = 0
⊢ (x + y).intDegree ≤ max x.intDegree y.intDegree

case neg
K : Type u
inst✝ : Field K
x y : RatFunc K
hy : y ≠ 0
hxy : x + y ≠ 0
hx : ¬x = 0
⊢ (x + y).intDegree ≤ max x.intDegree y.intDegree
tactic: by_cases hx : x = 0
state_before: case neg
K : Type u
inst✝ : Field K
x y : RatFunc K
hy : y ≠ 0
hxy : x + y ≠ 0
hx : ¬x = 0
⊢ (x + y).intDegree ≤ max x.intDegree y.intDegree
state_after: case neg
K : Type u
inst✝ : Field K
x y : RatFunc K
hy : y ≠ 0
hxy : x + y ≠ 0
hx : ¬x = 0
⊢ (x.num * y.denom + x.denom * y.num).natDegree ≤ max (x.num * y.denom).natDegree (x.denom * y.num).natDegree
tactic: rw [intDegree_add hxy, ←
    natDegree_num_mul_right_sub_natDegree_denom_mul_left_eq_intDegree hx y.denom_ne_zero,
    mul_comm y.denom, ←
    natDegree_num_mul_right_sub_natDegree_denom_mul_left_eq_intDegree hy x.denom_ne_zero,
    le_max_iff, sub_le_sub_iff_right, Int.ofNat_le, sub_le_sub_iff_right, Int.ofNat_le, ←
    le_max_iff, mul_comm y.num]
state_before: case neg
K : Type u
inst✝ : Field K
x y : RatFunc K
hy : y ≠ 0
hxy : x + y ≠ 0
hx : ¬x = 0
⊢ (x.num * y.denom + x.denom * y.num).natDegree ≤ max (x.num * y.denom).natDegree (x.denom * y.num).natDegree
state_after: no goals
tactic: exact natDegree_add_le _ _
Theorem: CategoryTheory.ShortComplex.ShortExact.singleTriangleIso_hom_hom₂
File: Mathlib/Algebra/Homology/DerivedCategory/SingleTriangle.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
S : ShortComplex C
hS : S.ShortExact
⊢ hS.singleTriangle ≅ triangleOfSES ⋯
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
S : ShortComplex C
hS : S.ShortExact
e : (SingleFunctors.evaluation C (DerivedCategory C) 0).obj (singleFunctors C) ≅
  (SingleFunctors.evaluation C (DerivedCategory C) 0).obj ((CochainComplex.singleFunctors C).postcomp Q) :=
  (SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso (singleFunctorsPostcompQIso C)
⊢ hS.singleTriangle ≅ triangleOfSES ⋯
tactic: let e := (SingleFunctors.evaluation _ _ 0).mapIso (singleFunctorsPostcompQIso C)
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
S : ShortComplex C
hS : S.ShortExact
e : (SingleFunctors.evaluation C (DerivedCategory C) 0).obj (singleFunctors C) ≅
  (SingleFunctors.evaluation C (DerivedCategory C) 0).obj ((CochainComplex.singleFunctors C).postcomp Q) :=
  (SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso (singleFunctorsPostcompQIso C)
⊢ hS.singleTriangle ≅ triangleOfSES ⋯
state_after: case refine_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
S : ShortComplex C
hS : S.ShortExact
e : (SingleFunctors.evaluation C (DerivedCategory C) 0).obj (singleFunctors C) ≅
  (SingleFunctors.evaluation C (DerivedCategory C) 0).obj ((CochainComplex.singleFunctors C).postcomp Q) :=
  (SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso (singleFunctorsPostcompQIso C)
⊢ hS.singleTriangle.mor₁ ≫ (e.app S.X₂).hom = (e.app S.X₁).hom ≫ (triangleOfSES ⋯).mor₁

case refine_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
S : ShortComplex C
hS : S.ShortExact
e : (SingleFunctors.evaluation C (DerivedCategory C) 0).obj (singleFunctors C) ≅
  (SingleFunctors.evaluation C (DerivedCategory C) 0).obj ((CochainComplex.singleFunctors C).postcomp Q) :=
  (SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso (singleFunctorsPostcompQIso C)
⊢ hS.singleTriangle.mor₂ ≫ (e.app S.X₃).hom = (e.app S.X₂).hom ≫ (triangleOfSES ⋯).mor₂

case refine_3
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasDerivedCategory C
S : ShortComplex C
hS : S.ShortExact
e : (SingleFunctors.evaluation C (DerivedCategory C) 0).obj (singleFunctors C) ≅
  (SingleFunctors.evaluation C (DerivedCategory C) 0).obj ((CochainComplex.singleFunctors C).postcomp Q) :=
  (SingleFunctors.evaluation C (DerivedCategory C) 0).mapIso (singleFunctorsPostcompQIso C)
⊢ hS.singleTriangle.mor₃ ≫ (shiftFunctor (DerivedCategory C) 1).map (e.app S.X₁).hom =
    (e.app S.X₃).hom ≫ (triangleOfSES ⋯).mor₃
tactic: refine Triangle.isoMk _ _ (e.app S.X₁) (e.app S.X₂) (e.app S.X₃) ?_ ?_ ?_
Theorem: Nat.Primrec.casesOn'
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: f g : ℕ → ℕ
hf : Nat.Primrec f
hg : Nat.Primrec g
n : ℕ
⊢ unpaired
      (fun z n =>
        Nat.rec (f z)
          (fun y IH =>
            g (Nat.pair (unpair (Nat.pair z (Nat.pair y IH))).1 (unpair (unpair (Nat.pair z (Nat.pair y IH))).2).1))
          n)
      n =
    unpaired (fun z n => Nat.casesOn n (f z) fun y => g (Nat.pair z y)) n
state_after: no goals
tactic: simp
Theorem: Quaternion.norm_exp
File: Mathlib/Analysis/NormedSpace/QuaternionExponential.lean

Proof steps:
state_before: q : ℍ
⊢ ‖exp ℝ q‖ = ‖exp ℝ q.re‖
state_after: no goals
tactic: rw [norm_eq_sqrt_real_inner (exp ℝ q), inner_self, normSq_exp, Real.sqrt_sq_eq_abs,
    Real.norm_eq_abs]
Theorem: ZMod.addOrderOf_coe'
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: a n : ℕ
a0 : a ≠ 0
⊢ addOrderOf ↑a = n / n.gcd a
state_after: no goals
tactic: rw [← Nat.smul_one_eq_cast, addOrderOf_nsmul' _ a0, ZMod.addOrderOf_one]
Theorem: List.nil_union
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : BEq α
l : List α
⊢ [] ∪ l = l
state_after: no goals
tactic: simp [List.union_def, foldr]
Theorem: Filter.mem_limsup_iff_frequently_mem
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
p : ι → Prop
s : ι → Set α
𝓕 : Filter ι
a : α
⊢ a ∈ limsup s 𝓕 ↔ ∃ᶠ (i : ι) in 𝓕, a ∈ s i
state_after: no goals
tactic: simp only [Filter.Frequently, iff_not_comm, ← mem_compl_iff, limsup_compl, comp_apply,
    mem_liminf_iff_eventually_mem]
Theorem: Ordinal.omega_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
⊢ a < o
state_after: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ a < o
tactic: let ⟨n, e⟩ := lt_omega.1 h
state_before: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ a < o
state_after: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ succ ↑n ≤ o
tactic: rw [e, ← succ_le_iff]
state_before: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ succ ↑n ≤ o
state_after: no goals
tactic: exact H (n + 1)
Theorem: MeasureTheory.vadd_set_ae_eq
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
s t : Set α
⊢ c • s =ᶠ[ae μ] c • t ↔ s =ᶠ[ae μ] t
state_after: no goals
tactic: simp only [Filter.eventuallyLE_antisymm_iff, smul_set_ae_le]
Theorem: CategoryTheory.Pi.eqToEquivalenceFunctorIso_inv
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
f : J → I
i' j' : J
h : i' = j'
⊢ (eqToEquivalence C ⋯).functor = (eqToEquivalence (fun i' => C (f i')) h).functor
state_after: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
f : J → I
i' : J
⊢ (eqToEquivalence C ⋯).functor = (eqToEquivalence (fun i' => C (f i')) ⋯).functor
tactic: subst h
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝ : (i : I) → Category.{v₁, u₁} (C i)
f : J → I
i' : J
⊢ (eqToEquivalence C ⋯).functor = (eqToEquivalence (fun i' => C (f i')) ⋯).functor
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.Reachable.exists_path_of_dist
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
hr : G.Reachable u v
⊢ ∃ p, p.IsPath ∧ p.length = G.dist u v
state_after: case intro
V : Type u_1
G : SimpleGraph V
u v w : V
hr : G.Reachable u v
p : G.Walk u v
h : p.length = G.dist u v
⊢ ∃ p, p.IsPath ∧ p.length = G.dist u v
tactic: obtain ⟨p, h⟩ := hr.exists_walk_length_eq_dist
state_before: case intro
V : Type u_1
G : SimpleGraph V
u v w : V
hr : G.Reachable u v
p : G.Walk u v
h : p.length = G.dist u v
⊢ ∃ p, p.IsPath ∧ p.length = G.dist u v
state_after: no goals
tactic: exact ⟨p, p.isPath_of_length_eq_dist h, h⟩
Theorem: exists_eq_pow_of_mul_eq_pow_of_coprime
File: Mathlib/RingTheory/IntegralDomain.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
cp : IsCoprime a b
h : a * b = c ^ n
⊢ ∃ d, a = d ^ n
state_after: M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
cp : IsCoprime a b
h : a * b = c ^ n
⊢ GCDMonoid.gcd a b ∣ 1
tactic: refine exists_eq_pow_of_mul_eq_pow (isUnit_of_dvd_one ?_) h
state_before: M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
cp : IsCoprime a b
h : a * b = c ^ n
⊢ GCDMonoid.gcd a b ∣ 1
state_after: case intro.intro
M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
h : a * b = c ^ n
x y : R
hxy : x * a + y * b = 1
⊢ GCDMonoid.gcd a b ∣ 1
tactic: obtain ⟨x, y, hxy⟩ := cp
state_before: case intro.intro
M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
h : a * b = c ^ n
x y : R
hxy : x * a + y * b = 1
⊢ GCDMonoid.gcd a b ∣ 1
state_after: case intro.intro
M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
h : a * b = c ^ n
x y : R
hxy : x * a + y * b = 1
⊢ GCDMonoid.gcd a b ∣ x * a + y * b
tactic: rw [← hxy]
state_before: case intro.intro
M : Type u_1
inst✝⁵ : CancelMonoidWithZero M
inst✝⁴ : Finite M
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : IsDomain R
inst✝¹ : GCDMonoid R
inst✝ : Unique Rˣ
a b c : R
n : ℕ
h : a * b = c ^ n
x y : R
hxy : x * a + y * b = 1
⊢ GCDMonoid.gcd a b ∣ x * a + y * b
state_after: no goals
tactic: exact  -- Porting note: added `GCDMonoid.` twice
    dvd_add (dvd_mul_of_dvd_right (GCDMonoid.gcd_dvd_left _ _) _)
      (dvd_mul_of_dvd_right (GCDMonoid.gcd_dvd_right _ _) _)
Theorem: WithTop.image_coe_Icc
File: Mathlib/Order/Interval/Set/WithBotTop.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some '' Icc a b = Icc ↑a ↑b
state_after: no goals
tactic: rw [← preimage_coe_Icc, image_preimage_eq_inter_range, range_coe,
    inter_eq_self_of_subset_left
      (Subset.trans Icc_subset_Iic_self <| Iic_subset_Iio.2 <| coe_lt_top b)]
Theorem: MeasureTheory.IsSetSemiring.disjoint_sUnion_diffFinset
File: Mathlib/MeasureTheory/SetSemiring.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ Disjoint t (⋃₀ ↑(hC.diffFinset hs ht))
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ Disjoint t (s \ t)
tactic: rw [hC.sUnion_diffFinset]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
hC : IsSetSemiring C
hs : s ∈ C
ht : t ∈ C
⊢ Disjoint t (s \ t)
state_after: no goals
tactic: exact disjoint_sdiff_right
Theorem: top_bihimp
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ ⊤ ⇔ a = a
state_after: no goals
tactic: rw [bihimp_comm, bihimp_top]
Theorem: CFC.log_zero
File: Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean

Proof steps:
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
⊢ log 0 = 0
state_after: no goals
tactic: simp [log]
Theorem: List.toFinset_append
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ (l ++ l').toFinset = l.toFinset ∪ l'.toFinset
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
⊢ ([] ++ l').toFinset = [].toFinset ∪ l'.toFinset

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a hd : α
tl : List α
hl : (tl ++ l').toFinset = tl.toFinset ∪ l'.toFinset
⊢ (hd :: tl ++ l').toFinset = (hd :: tl).toFinset ∪ l'.toFinset
tactic: induction' l with hd tl hl
Theorem: MonotoneOn.image_upperBounds_subset_upperBounds_image
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
a : α
Hf : MonotoneOn f t
Hst : s ⊆ t
⊢ f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
a✝ : α
Hf : MonotoneOn f t
Hst : s ⊆ t
a : α
ha : a ∈ upperBounds s ∩ t
⊢ f a ∈ upperBounds (f '' s)
tactic: rintro _ ⟨a, ha, rfl⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s t : Set α
a✝ : α
Hf : MonotoneOn f t
Hst : s ⊆ t
a : α
ha : a ∈ upperBounds s ∩ t
⊢ f a ∈ upperBounds (f '' s)
state_after: no goals
tactic: exact Hf.mem_upperBounds_image Hst ha.1 ha.2
Theorem: Finsupp.sum_smul_index_linearMap'
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
M : Type u_4
M₂ : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
v : α →₀ M
c : R
h : α → M →ₗ[R] M₂
⊢ ((c • v).sum fun a => ⇑(h a)) = c • v.sum fun a => ⇑(h a)
state_after: α : Type u_1
β : Type u_2
R : Type u_3
M : Type u_4
M₂ : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
v : α →₀ M
c : R
h : α → M →ₗ[R] M₂
⊢ (v.sum fun i c_1 => (h i) (c • c_1)) = v.sum fun a b => c • (h a) b

α : Type u_1
β : Type u_2
R : Type u_3
M : Type u_4
M₂ : Type u_5
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
v : α →₀ M
c : R
h : α → M →ₗ[R] M₂
⊢ ∀ (i : α), (h i) 0 = 0
tactic: rw [Finsupp.sum_smul_index', Finsupp.smul_sum]
Theorem: IsCyclotomicExtension.zeta_isRoot
File: Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean

Proof steps:
state_before: p n : ℕ+
A : Type w
B : Type z
K : Type u
L : Type v
C : Type w
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : IsCyclotomicExtension {n} A B
inst✝¹ : IsDomain B
inst✝ : NeZero ↑↑n
⊢ (cyclotomic (↑n) B).IsRoot (zeta n A B)
state_after: case a
p n : ℕ+
A : Type w
B : Type z
K : Type u
L : Type v
C : Type w
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : IsCyclotomicExtension {n} A B
inst✝¹ : IsDomain B
inst✝ : NeZero ↑↑n
⊢ (cyclotomic (↑n) B).IsRoot (zeta n A B) ↔ (aeval (zeta n A B)) (cyclotomic (↑n) A) = 0
tactic: convert aeval_zeta n A B using 0
state_before: case a
p n : ℕ+
A : Type w
B : Type z
K : Type u
L : Type v
C : Type w
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : IsCyclotomicExtension {n} A B
inst✝¹ : IsDomain B
inst✝ : NeZero ↑↑n
⊢ (cyclotomic (↑n) B).IsRoot (zeta n A B) ↔ (aeval (zeta n A B)) (cyclotomic (↑n) A) = 0
state_after: no goals
tactic: rw [IsRoot.def, aeval_def, eval₂_eq_eval_map, map_cyclotomic]
Theorem: Balanced.sub
File: Mathlib/Analysis/LocallyConvex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
hs : Balanced 𝕜 s
ht : Balanced 𝕜 t
⊢ Balanced 𝕜 (s - t)
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
hs : Balanced 𝕜 s
ht : Balanced 𝕜 t
⊢ Balanced 𝕜 (s + -t)
tactic: simp_rw [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
hs : Balanced 𝕜 s
ht : Balanced 𝕜 t
⊢ Balanced 𝕜 (s + -t)
state_after: no goals
tactic: exact hs.add ht.neg