ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Path.symm_apply
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
⊢ Continuous (⇑γ ∘ σ)
state_after: no goals
tactic: continuity
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
⊢ { toFun := ⇑γ ∘ σ, continuous_toFun := ⋯ }.toFun 0 = y
state_after: no goals
tactic: simpa [-Path.target] using γ.target
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
⊢ { toFun := ⇑γ ∘ σ, continuous_toFun := ⋯ }.toFun 1 = x
state_after: no goals
tactic: simpa [-Path.source] using γ.source
Theorem: Mathlib.Vector.sum_set
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Monoid α
v : Vector α n
i : Fin n
a : α
⊢ (v.set i a).toList.prod = (take (↑i) v).toList.prod * a * (drop (↑i + 1) v).toList.prod
state_after: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Monoid α
v : Vector α n
i : Fin n
a : α
⊢ ((List.take (↑i) v.toList).prod * if ↑i < v.toList.length then a else 1) * (List.drop (↑i + 1) v.toList).prod =
    (take (↑i) v).toList.prod * a * (drop (↑i + 1) v).toList.prod
tactic: refine (List.prod_set v.toList i a).trans ?_
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Monoid α
v : Vector α n
i : Fin n
a : α
⊢ ((List.take (↑i) v.toList).prod * if ↑i < v.toList.length then a else 1) * (List.drop (↑i + 1) v.toList).prod =
    (take (↑i) v).toList.prod * a * (drop (↑i + 1) v).toList.prod
state_after: no goals
tactic: simp_all
Theorem: Filter.nonneg_sub_iff
File: Mathlib/Order/Filter/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
⊢ 1 ≤ f / g ↔ ¬Disjoint f g
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
h : 1 ≤ f / g
hfg : Disjoint f g
⊢ False

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝³ : Group α
inst✝² : DivisionMonoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
m : F
f g f₁ g₁ : Filter α
f₂ g₂ : Filter β
⊢ ¬Disjoint f g → 1 ≤ f / g
tactic: refine ⟨fun h hfg => ?_, ?_⟩
Theorem: Real.ofCauchy_sup
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := ⟦a ⊔ b⟧ } = Real.sup { cauchy := ⟦a⟧ } { cauchy := ⟦b⟧ }
state_after: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := ⟦a ⊔ b⟧ } =
    match { cauchy := ⟦a⟧ }, { cauchy := ⟦b⟧ } with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_1 => x ⊔ x_1) ⋯ x y }
tactic: rw [sup_def]
state_before: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := ⟦a ⊔ b⟧ } =
    match { cauchy := ⟦a⟧ }, { cauchy := ⟦b⟧ } with
    | { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x x_1 => x ⊔ x_1) ⋯ x y }
state_after: no goals
tactic: rfl
Theorem: existsUnique_add_zsmul_mem_Ico
File: Mathlib/Algebra/Order/Archimedean.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
a : α
ha : 0 < a
b c : α
⊢ ∃! x, b + (Equiv.neg ℤ) x • a ∈ Ico c (c + a)
state_after: no goals
tactic: simpa only [Equiv.neg_apply, mem_Ico, neg_zsmul, ← sub_eq_add_neg, le_sub_iff_add_le, zero_add,
      add_comm c, sub_lt_iff_lt_add', add_assoc] using existsUnique_zsmul_near_of_pos' ha (b - c)
Theorem: Multiset.add_eq_union_iff_disjoint
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
⊢ s + t = s ∪ t ↔ s.Disjoint t
state_after: no goals
tactic: simp_rw [← inter_eq_zero_iff_disjoint, ext, count_add, count_union, count_inter, count_zero,
    Nat.min_eq_zero_iff, Nat.add_eq_max_iff]
Theorem: CFC.spectrum_zero_eq
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : TopologicalSpace A
inst✝⁵ : Ring A
inst✝⁴ : StarRing A
inst✝³ : Algebra R A
inst✝² : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
inst✝¹ : UniqueContinuousFunctionalCalculus R A
inst✝ : Nontrivial A
⊢ spectrum R 0 = {0}
state_after: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : TopologicalSpace A
inst✝⁵ : Ring A
inst✝⁴ : StarRing A
inst✝³ : Algebra R A
inst✝² : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
inst✝¹ : UniqueContinuousFunctionalCalculus R A
inst✝ : Nontrivial A
this : 0 = (algebraMap R A) 0
⊢ spectrum R 0 = {0}
tactic: have : (0 : A) = algebraMap R A 0 := Eq.symm (RingHom.map_zero (algebraMap R A))
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : TopologicalSpace A
inst✝⁵ : Ring A
inst✝⁴ : StarRing A
inst✝³ : Algebra R A
inst✝² : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
inst✝¹ : UniqueContinuousFunctionalCalculus R A
inst✝ : Nontrivial A
this : 0 = (algebraMap R A) 0
⊢ spectrum R 0 = {0}
state_after: no goals
tactic: rw [this, spectrum_algebraMap_eq]
Theorem: CategoryTheory.Limits.Types.Small.limitCone_pt_ext
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : Small.{u, max u v} ↑F.sections
x y : (limitCone F).pt
w : (equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y
⊢ x = y
state_after: no goals
tactic: aesop
Theorem: Booleanisation.comp_le_comp
File: Mathlib/Order/Booleanisation.lean

Proof steps:
state_before: α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
⊢ comp a ≤ comp b → b ≤ a
state_after: case comp
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : b ≤ a
⊢ b ≤ a
tactic: rintro ⟨_⟩
state_before: case comp
α : Type u_1
inst✝ : GeneralizedBooleanAlgebra α
x y : Booleanisation α
a b : α
a✝ : b ≤ a
⊢ b ≤ a
state_after: no goals
tactic: assumption
Theorem: MeasureTheory.measure_preimage_eq_zero_iff_of_countable
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : α → β
hs : s.Countable
⊢ μ (f ⁻¹' s) = 0 ↔ ∀ x ∈ s, μ (f ⁻¹' {x}) = 0
state_after: no goals
tactic: rw [← biUnion_preimage_singleton, measure_biUnion_null_iff hs]
Theorem: Nat.prod_pow_factorization_choose
File: Mathlib/Data/Nat/Choose/Factorization.lean

Proof steps:
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = n.choose k
state_after: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = (n.choose k).factorization.prod fun x x_1 => x ^ x_1
tactic: conv => -- Porting note: was `nth_rw_rhs`
    rhs
    rw [← factorization_prod_pow_eq_self (choose_pos hkn).ne']
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = (n.choose k).factorization.prod fun x x_1 => x ^ x_1
state_after: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ((n.choose k).factorization.prod fun x x_1 => x ^ x_1) = ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p
tactic: rw [eq_comm]
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ((n.choose k).factorization.prod fun x x_1 => x ^ x_1) = ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p
state_after: case h
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ (n.choose k).factorization.support ⊆ Finset.range (n + 1)

case hf
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∀ x ∈ Finset.range (n + 1),
    x ∉ (n.choose k).factorization.support → (fun x x_1 => x ^ x_1) x ((n.choose k).factorization x) = 1
tactic: apply Finset.prod_subset
Theorem: PosNum.cast_le
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : PosNum
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : PosNum
⊢ ¬↑n < ↑m ↔ m ≤ n
tactic: rw [← not_lt]
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
m n : PosNum
⊢ ¬↑n < ↑m ↔ m ≤ n
state_after: no goals
tactic: exact not_congr cast_lt
Theorem: MeasureTheory.pdf.IsUniform.toMeasurable
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hu : IsUniform X s ℙ μ
⊢ IsUniform X (toMeasurable μ s) ℙ μ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hu : Measure.map X ℙ = ProbabilityTheory.cond μ s
⊢ Measure.map X ℙ = ProbabilityTheory.cond μ (toMeasurable μ s)
tactic: unfold IsUniform at *
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hu : Measure.map X ℙ = ProbabilityTheory.cond μ s
⊢ Measure.map X ℙ = ProbabilityTheory.cond μ (toMeasurable μ s)
state_after: no goals
tactic: rwa [ProbabilityTheory.cond_toMeasurable_eq]
Theorem: finrank_eq_rank
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type w
ι' : Type w'
inst✝¹ : StrongRankCondition R
inst✝ : Module.Finite R M
⊢ ↑(finrank R M) = Module.rank R M
state_after: no goals
tactic: rw [FiniteDimensional.finrank, cast_toNat_of_lt_aleph0 (rank_lt_aleph0 R M)]
Theorem: Stream'.Seq.destruct_cons
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ (cons a ⟨f, al⟩).destruct = some (a, ⟨f, al⟩)
state_after: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ instFunctorOption.1 (fun a' => (a', tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩)) (get? ⟨some a :: ↑⟨f, al⟩, ⋯⟩ 0) =
    some (a, ⟨f, al⟩)
tactic: unfold cons destruct Functor.map
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ instFunctorOption.1 (fun a' => (a', tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩)) (get? ⟨some a :: ↑⟨f, al⟩, ⋯⟩ 0) =
    some (a, ⟨f, al⟩)
state_after: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩ = ⟨f, al⟩
tactic: apply congr_arg fun s => some (a, s)
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩ = ⟨f, al⟩
state_after: case a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ ↑(tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩) = ↑⟨f, al⟩
tactic: apply Subtype.eq
state_before: case a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : f.IsSeq
⊢ ↑(tail ⟨some a :: ↑⟨f, al⟩, ⋯⟩) = ↑⟨f, al⟩
state_after: no goals
tactic: dsimp [tail]
Theorem: List.neg_one_mem_of_prod_eq_neg_one
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
l : List ℤ
h : l.prod = -1
⊢ -1 ∈ l
state_after: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
l : List ℤ
h : l.prod = -1
x : ℤ
h₁ : x ∈ l
h₂ : x ≠ 1
⊢ -1 ∈ l
tactic: obtain ⟨x, h₁, h₂⟩ := exists_mem_ne_one_of_prod_ne_one (ne_of_eq_of_ne h (by decide))
state_before: case intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
l : List ℤ
h : l.prod = -1
x : ℤ
h₁ : x ∈ l
h₂ : x ≠ 1
⊢ -1 ∈ l
state_after: no goals
tactic: exact Or.resolve_left
    (Int.isUnit_iff.mp (prod_isUnit_iff.mp
      (h.symm ▸ ⟨⟨-1, -1, by decide, by decide⟩, rfl⟩ : IsUnit l.prod) x h₁)) h₂ ▸ h₁
Theorem: WeierstrassCurve.VariableChange.comp_assoc
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C✝ C'✝ C''✝ C C' C'' : VariableChange R
⊢ (C.comp C').comp C'' = C.comp (C'.comp C'')
state_after: no goals
tactic: ext <;> simp only [comp, Units.val_mul] <;> ring1
Theorem: Polynomial.IsUnitTrinomial.not_isUnit
File: Mathlib/Algebra/Polynomial/UnitTrinomial.lean

Proof steps:
state_before: p q : ℤ[X]
hp : p.IsUnitTrinomial
⊢ ¬IsUnit p
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
⊢ ¬IsUnit (trinomial k m n ↑u ↑v ↑w)
tactic: obtain ⟨k, m, n, hkm, hmn, u, v, w, rfl⟩ := hp
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
⊢ ¬IsUnit (trinomial k m n ↑u ↑v ↑w)
state_after: no goals
tactic: exact fun h =>
    ne_zero_of_lt hmn
      ((trinomial_natDegree hkm hmn w.ne_zero).symm.trans
        (natDegree_eq_of_degree_eq_some (degree_eq_zero_of_isUnit h)))
Theorem: Equiv.Perm.IsSwap.isCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝ : DecidableEq α
⊢ f.IsSwap → f.IsCycle
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
g : Perm α
x✝ y✝ : α
inst✝ : DecidableEq α
x y : α
hxy : x ≠ y
⊢ (swap x y).IsCycle
tactic: rintro ⟨x, y, hxy, rfl⟩
state_before: case intro.intro.intro
ι : Type u_1
α : Type u_2
β : Type u_3
g : Perm α
x✝ y✝ : α
inst✝ : DecidableEq α
x y : α
hxy : x ≠ y
⊢ (swap x y).IsCycle
state_after: no goals
tactic: exact isCycle_swap hxy
Theorem: IsScalarTower.Algebra.ext
File: Mathlib/Algebra/Algebra/Tower.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
r : S
x : A
⊢ A
state_after: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
r : S
x : A
I : Algebra S A
⊢ A
tactic: have I := h1
state_before: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
r : S
x : A
I : Algebra S A
⊢ A
state_after: no goals
tactic: exact r • x
state_before: R : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
M : Type v₁
inst✝¹² : CommSemiring R
inst✝¹¹ : CommSemiring S✝
inst✝¹⁰ : Semiring A✝
inst✝⁹ : Semiring B
inst✝⁸ : Algebra R S✝
inst✝⁷ : Algebra S✝ A✝
inst✝⁶ : Algebra S✝ B
inst✝⁵ : Algebra R A✝
inst✝⁴ : Algebra R B
inst✝³ : IsScalarTower R S✝ A✝
inst✝² : IsScalarTower R S✝ B
S : Type u
A : Type v
inst✝¹ : CommSemiring S
inst✝ : Semiring A
h1 h2 : Algebra S A
h :
  ∀ (r : S) (x : A),
    (let_fun I := h1;
      r • x) =
      r • x
r : S
⊢ (algebraMap S A) r = (algebraMap S A) r
state_after: no goals
tactic: simpa only [@Algebra.smul_def _ _ _ _ h1, @Algebra.smul_def _ _ _ _ h2, mul_one] using h r 1
Theorem: Matrix.smul_mulVec_assoc
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : NonUnitalNonAssocSemiring α
inst✝³ : Fintype n
inst✝² : Monoid R
inst✝¹ : DistribMulAction R α
inst✝ : IsScalarTower R α α
a : R
A : Matrix m n α
b : n → α
⊢ (a • A) *ᵥ b = a • A *ᵥ b
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : NonUnitalNonAssocSemiring α
inst✝³ : Fintype n
inst✝² : Monoid R
inst✝¹ : DistribMulAction R α
inst✝ : IsScalarTower R α α
a : R
A : Matrix m n α
b : n → α
x✝ : m
⊢ ((a • A) *ᵥ b) x✝ = (a • A *ᵥ b) x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : NonUnitalNonAssocSemiring α
inst✝³ : Fintype n
inst✝² : Monoid R
inst✝¹ : DistribMulAction R α
inst✝ : IsScalarTower R α α
a : R
A : Matrix m n α
b : n → α
x✝ : m
⊢ ((a • A) *ᵥ b) x✝ = (a • A *ᵥ b) x✝
state_after: no goals
tactic: apply smul_dotProduct
Theorem: Matroid.Indep.mem_closure_iff'
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ x ∈ M.closure I ↔ x ∈ M.E ∧ (M.Indep (insert x I) → x ∈ I)
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ ¬M.Indep (insert x I) ∧ x ∈ M.E ∨ x ∈ I ↔ x ∈ M.E ∧ (¬M.Indep (insert x I) ∨ x ∈ I)
tactic: rw [hI.mem_closure_iff, dep_iff, insert_subset_iff, and_iff_left hI.subset_ground,
    imp_iff_not_or]
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ ¬M.Indep (insert x I) ∧ x ∈ M.E ∨ x ∈ I ↔ x ∈ M.E ∧ (¬M.Indep (insert x I) ∨ x ∈ I)
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
this : I ⊆ M.E
⊢ ¬M.Indep (insert x I) ∧ x ∈ M.E ∨ x ∈ I ↔ x ∈ M.E ∧ (¬M.Indep (insert x I) ∨ x ∈ I)
tactic: have := hI.subset_ground
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
this : I ⊆ M.E
⊢ ¬M.Indep (insert x I) ∧ x ∈ M.E ∨ x ∈ I ↔ x ∈ M.E ∧ (¬M.Indep (insert x I) ∨ x ∈ I)
state_after: no goals
tactic: aesop
Theorem: PowerSeries.coeff_succ_X_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (coeff R (n + 1)) (X * φ) = (coeff R n) φ
state_after: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () 1 + single () n)) (X * φ) = (MvPowerSeries.coeff R (single () n)) φ
tactic: simp only [coeff, Finsupp.single_add, add_comm n 1]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () 1 + single () n)) (X * φ) = (MvPowerSeries.coeff R (single () n)) φ
state_after: case h.e'_3
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () n)) φ = 1 * (MvPowerSeries.coeff R (single () n)) φ
tactic: convert φ.coeff_add_monomial_mul (single () 1) (single () n) _
state_before: case h.e'_3
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () n)) φ = 1 * (MvPowerSeries.coeff R (single () n)) φ
state_after: no goals
tactic: rw [one_mul]
Theorem: CategoryTheory.Bicategory.LeftExtension.whiskerHom_right
File: Mathlib/CategoryTheory/Bicategory/Extension.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
g : a ⟶ c
s t : LeftExtension f g
i : s ⟶ t
x : B
h : c ⟶ x
⊢ (s.whisker h).hom ≫ (precomp x f).map (i.right ▷ h) = (t.whisker h).hom
state_after: B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
g : a ⟶ c
s t : LeftExtension f g
i : s ⟶ t
x : B
h : c ⟶ x
⊢ ((s.whisker h).hom ≫ (precomp x f).map (i.right ▷ h)) ≫ (α_ f t.extension h).inv =
    (t.whisker h).hom ≫ (α_ f t.extension h).inv
tactic: rw [← cancel_mono (α_ _ _ _).inv]
Theorem: FreeCommRing.exists_finset_support
File: Mathlib/RingTheory/FreeCommRing.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → β
x : FreeCommRing α
s : Set α
hfs : s.Finite
hxs : x.IsSupported s
⊢ x.IsSupported ↑hfs.toFinset
state_after: no goals
tactic: rwa [Set.Finite.coe_toFinset]
Theorem: Compactum.str_hom_commute
File: Mathlib/Topology/Category/Compactum.lean

Proof steps:
state_before: X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ f.f (X.str xs) = Y.str (Ultrafilter.map f.f xs)
state_after: X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ (X.a ≫ f.f) xs = Y.str (Ultrafilter.map f.f xs)
tactic: change (X.a ≫ f.f) _ = _
state_before: X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ (X.a ≫ f.f) xs = Y.str (Ultrafilter.map f.f xs)
state_after: X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ (β.map f.f ≫ Y.a) xs = Y.str (Ultrafilter.map f.f xs)
tactic: rw [← f.h]
state_before: X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ (β.map f.f ≫ Y.a) xs = Y.str (Ultrafilter.map f.f xs)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.ShortComplex.cyclesMapIso'_inv
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.115347, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
e : S₁ ≅ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ cyclesMap' e.hom h₁ h₂ ≫ cyclesMap' e.inv h₂ h₁ = 𝟙 h₁.K
state_after: no goals
tactic: rw [← cyclesMap'_comp, e.hom_inv_id, cyclesMap'_id]
state_before: C : Type u_1
inst✝¹ : Category.{?u.115347, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
e : S₁ ≅ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ cyclesMap' e.inv h₂ h₁ ≫ cyclesMap' e.hom h₁ h₂ = 𝟙 h₂.K
state_after: no goals
tactic: rw [← cyclesMap'_comp, e.inv_hom_id, cyclesMap'_id]
Theorem: NormedAddGroupHom.ker_le_ker_completion
File: Mathlib/Analysis/Normed/Group/HomCompletion.lean

Proof steps:
state_before: G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
⊢ (toCompl.comp (incl f.ker)).range ≤ f.completion.ker
state_after: case intro.mk
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : G
h₀ : f g = 0
⊢ (toCompl.comp (incl f.ker)).toAddMonoidHom ⟨g, h₀⟩ ∈ f.completion.ker
tactic: rintro _ ⟨⟨g, h₀ : f g = 0⟩, rfl⟩
state_before: case intro.mk
G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
g : G
h₀ : f g = 0
⊢ (toCompl.comp (incl f.ker)).toAddMonoidHom ⟨g, h₀⟩ ∈ f.completion.ker
state_after: no goals
tactic: simp [h₀, mem_ker, Completion.coe_zero]