ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv_apply_val
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

Proof steps:
state_before: I : MulticospanIndex (Type u)
c : Multifork I
hc : IsLimit c
s : I.sections
i : I.L
⊢ c.ι i ((sectionsEquiv hc) s) = s.val i
state_after: case intro
I : MulticospanIndex (Type u)
c : Multifork I
hc : IsLimit c
i : I.L
x : c.pt
⊢ c.ι i ((sectionsEquiv hc) ((sectionsEquiv hc).symm x)) = ((sectionsEquiv hc).symm x).val i
tactic: obtain ⟨x, rfl⟩ := (sectionsEquiv hc).symm.surjective s
state_before: case intro
I : MulticospanIndex (Type u)
c : Multifork I
hc : IsLimit c
i : I.L
x : c.pt
⊢ c.ι i ((sectionsEquiv hc) ((sectionsEquiv hc).symm x)) = ((sectionsEquiv hc).symm x).val i
state_after: no goals
tactic: simp
Theorem: ComplexShape.boundaryGE_embeddingUpIntGE_iff
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: p : ℤ
n : ℕ
⊢ (embeddingUpIntGE p).BoundaryGE n ↔ n = 0
state_after: case mp
p : ℤ
n : ℕ
⊢ (embeddingUpIntGE p).BoundaryGE n → n = 0

case mpr
p : ℤ
n : ℕ
⊢ n = 0 → (embeddingUpIntGE p).BoundaryGE n
tactic: constructor
Theorem: Submodule.FG.map
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
P : Type u_3
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
f : M →ₗ[R] P
N : Submodule R M
hs : N.FG
t : Set M
ht : t.Finite ∧ span R t = N
⊢ span R (⇑f '' t) = Submodule.map f N
state_after: no goals
tactic: rw [span_image, ht.2]
Theorem: Polynomial.coeff_mem_coeffs
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
p : R[X]
n : ℕ
h : p.coeff n ≠ 0
⊢ p.coeff n ∈ p.coeffs
state_after: no goals
tactic: classical
  simp only [coeffs, exists_prop, mem_support_iff, Finset.mem_image, Ne]
  exact ⟨n, h, rfl⟩
Theorem: Option.naturality
File: Mathlib/Control/Traversable/Instances.lean

Proof steps:
state_before: F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative G
η : ApplicativeTransformation F G
inst✝ : LawfulApplicative F
α : Type u_1
β : Type u
f : α → F β
x : Option α
⊢ (fun {α} => η.app α) (Option.traverse f x) = Option.traverse ((fun {α} => η.app α) ∘ f) x
state_after: no goals
tactic: cases' x with x <;> simp! [*, functor_norm, ApplicativeTransformation.preserves_map,
    ApplicativeTransformation.preserves_seq, ApplicativeTransformation.preserves_pure]
Theorem: Complex.not_lt_iff
File: Mathlib/Data/Complex/Order.lean

Proof steps:
state_before: z w : ℂ
⊢ ¬z < w ↔ w.re ≤ z.re ∨ z.im ≠ w.im
state_after: no goals
tactic: rw [lt_def, not_and_or, not_lt]
Theorem: List.getElem?_zipWith'
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₁ : List α
l₂ : List β
i : ℕ
⊢ (zipWith f l₁ l₂)[i]? = (Option.map f l₁[i]?).bind fun g => Option.map g l₂[i]?
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l₂ : List β
i : ℕ
⊢ (zipWith f [] l₂)[i]? = (Option.map f [][i]?).bind fun g => Option.map g l₂[i]?

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
head : α
tail : List α
tail_ih✝ : ∀ (l₂ : List β) (i : ℕ), (zipWith f tail l₂)[i]? = (Option.map f tail[i]?).bind fun g => Option.map g l₂[i]?
l₂ : List β
i : ℕ
⊢ (zipWith f (head :: tail) l₂)[i]? = (Option.map f (head :: tail)[i]?).bind fun g => Option.map g l₂[i]?
tactic: induction' l₁ with head tail generalizing l₂ i
Theorem: MvPolynomial.support_mul_X
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
s : σ
p : MvPolynomial σ R
⊢ ∀ (y : R), y * 1 = 0 ↔ y = 0
state_after: no goals
tactic: simp
Theorem: interior_eq_nhds'
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x✝ : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
x : X
⊢ x ∈ interior s ↔ x ∈ {x | s ∈ 𝓝 x}
state_after: no goals
tactic: simp only [mem_interior, mem_nhds_iff, mem_setOf_eq]
Theorem: rank_eq_of_surjective
File: Mathlib/LinearAlgebra/Dimension/RankNullity.lean

Proof steps:
state_before: R : Type u_1
M M₁ M₂ M₃ : Type u
M' : Type v
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M₁
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'
inst✝ : HasRankNullity.{u, u_1} R
f : M →ₗ[R] M₁
h : Surjective ⇑f
⊢ Module.rank R M = Module.rank R M₁ + Module.rank R ↥(LinearMap.ker f)
state_after: no goals
tactic: rw [← rank_range_add_rank_ker f, ← rank_range_of_surjective f h]
Theorem: inner_self_im
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ im ⟪x, x⟫_𝕜 = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ I * ((starRingEnd 𝕜) ⟪x, x⟫_𝕜 - ⟪x, x⟫_𝕜) / 2 = ↑0
tactic: rw [← @ofReal_inj 𝕜, im_eq_conj_sub]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ I * ((starRingEnd 𝕜) ⟪x, x⟫_𝕜 - ⟪x, x⟫_𝕜) / 2 = ↑0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.OverPresheafAux.map_mkPrecomp_eqToHom
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y : C
f : X ⟶ Y
g g' : yoneda.obj Y ⟶ A
h : g = g'
x : F.obj (op (CostructuredArrow.mk g'))
⊢ op (CostructuredArrow.mk g') = op (CostructuredArrow.mk g)
state_after: no goals
tactic: rw [h]
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y : C
f : X ⟶ Y
g g' : yoneda.obj Y ⟶ A
h : g = g'
x : F.obj (op (CostructuredArrow.mk g'))
⊢ op (CostructuredArrow.mk (yoneda.map f ≫ g')) = op (CostructuredArrow.mk (yoneda.map f ≫ g))
state_after: no goals
tactic: rw [h]
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y : C
f : X ⟶ Y
g g' : yoneda.obj Y ⟶ A
h : g = g'
x : F.obj (op (CostructuredArrow.mk g'))
⊢ F.map (CostructuredArrow.mkPrecomp g f).op (F.map (eqToHom ⋯) x) =
    F.map (eqToHom ⋯) (F.map (CostructuredArrow.mkPrecomp g' f).op x)
state_after: no goals
tactic: aesop_cat
Theorem: MeasureTheory.measure_preimage_add
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulLeftInvariant
g : G
A : Set G
⊢ (Measure.map (fun h => g * h) μ) A = μ A
state_after: no goals
tactic: rw [map_mul_left_eq_self μ g]
Theorem: Finset.fin_map
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
s : Finset ℕ
⊢ map Fin.valEmbedding (Finset.fin n s) = filter (fun x => x < n) s
state_after: no goals
tactic: simp [Finset.fin, Finset.map_map]
Theorem: Nat.dvd_mul_gcd_iff_dvd_mul
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: x n m : ℕ
⊢ x ∣ n * x.gcd m ↔ x ∣ n * m
state_after: no goals
tactic: rw [mul_comm, dvd_gcd_mul_iff_dvd_mul, mul_comm]
Theorem: Irrational.of_one_div
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
h : Irrational (1 / x)
⊢ Irrational (↑1 / x)
state_after: no goals
tactic: rwa [cast_one]
Theorem: Set.Ico_eq_Ico_iff
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : a₁ < b₁ ∨ a₂ < b₂
e : Ico a₁ b₁ = Ico a₂ b₂
⊢ a₁ = a₂ ∧ b₁ = b₂
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : a₁ < b₁ ∨ a₂ < b₂
e : Ico a₁ b₁ ⊆ Ico a₂ b₂ ∧ Ico a₂ b₂ ⊆ Ico a₁ b₁
⊢ a₁ = a₂ ∧ b₁ = b₂
tactic: simp only [Subset.antisymm_iff] at e
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : a₁ < b₁ ∨ a₂ < b₂
e : Ico a₁ b₁ ⊆ Ico a₂ b₂ ∧ Ico a₂ b₂ ⊆ Ico a₁ b₁
⊢ a₁ = a₂ ∧ b₁ = b₂
state_after: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : a₁ < b₁ ∨ a₂ < b₂
e : Ico a₁ b₁ ⊆ Ico a₂ b₂ ∧ Ico a₂ b₂ ⊆ Ico a₁ b₁
⊢ (a₁ ≤ a₂ ∧ a₂ ≤ a₁) ∧ b₁ ≤ b₂ ∧ b₂ ≤ b₁
tactic: simp only [le_antisymm_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : a₁ < b₁ ∨ a₂ < b₂
e : Ico a₁ b₁ ⊆ Ico a₂ b₂ ∧ Ico a₂ b₂ ⊆ Ico a₁ b₁
⊢ (a₁ ≤ a₂ ∧ a₂ ≤ a₁) ∧ b₁ ≤ b₂ ∧ b₂ ≤ b₁
state_after: no goals
tactic: cases' h with h h <;>
      simp only [gt_iff_lt, not_lt, Ico_subset_Ico_iff h] at e <;>
      [ rcases e with ⟨⟨h₁, h₂⟩, e'⟩; rcases e with ⟨e', ⟨h₁, h₂⟩⟩ ] <;>
      -- Porting note: restore `tauto`
      have hab := (Ico_subset_Ico_iff <| h₁.trans_lt <| h.trans_le h₂).1 e' <;>
      [ exact ⟨⟨hab.left, h₁⟩, ⟨h₂, hab.right⟩⟩; exact ⟨⟨h₁, hab.left⟩, ⟨hab.right, h₂⟩⟩ ]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : a₁ < b₁ ∨ a₂ < b₂
x✝ : a₁ = a₂ ∧ b₁ = b₂
h₁ : a₁ = a₂
h₂ : b₁ = b₂
⊢ Ico a₁ b₁ = Ico a₂ b₂
state_after: no goals
tactic: rw [h₁, h₂]
Theorem: ContinuousLinearEquiv.dimH_univ
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁶ : EMetricSpace X
inst✝⁵ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s t : Set X
𝕜 : Type u_4
E : Type u_5
F : Type u_6
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
e : E ≃L[𝕜] F
⊢ dimH univ = dimH univ
state_after: no goals
tactic: rw [← e.dimH_preimage, preimage_univ]
Theorem: inv_mul_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a⁻¹ * b = c
⊢ b = a * c
state_after: no goals
tactic: rw [← h, mul_inv_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b = a * c
⊢ a⁻¹ * b = c
state_after: no goals
tactic: rw [h, inv_mul_cancel_left]
Theorem: mul_neg_one
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : MulOneClass α
inst✝ : HasDistribNeg α
a : α
⊢ a * -1 = -a
state_after: no goals
tactic: simp
Theorem: Function.Injective.hasSum_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a b : α
s : Finset β
g : γ → β
hg : Injective g
hf : ∀ x ∉ Set.range g, f x = 1
⊢ HasProd (f ∘ g) a ↔ HasProd f a
state_after: no goals
tactic: simp only [HasProd, Tendsto, comp_apply, hg.map_atTop_finset_prod_eq hf]
Theorem: MeasurableEmbedding.measurable_rangeSplitting
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → γ
hf : MeasurableEmbedding f
s : Set α
hs : MeasurableSet s
⊢ MeasurableSet (rangeSplitting f ⁻¹' s)
state_after: no goals
tactic: rwa [preimage_rangeSplitting hf.injective,
    ← (subtype_coe hf.measurableSet_range).measurableSet_image, ← image_comp,
    coe_comp_rangeFactorization, hf.measurableSet_image]
Theorem: inv_mul_le_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ b⁻¹ * a ≤ c ↔ a ≤ b * c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a / b ≤ c ↔ a ≤ b * c
tactic: rw [inv_eq_one_div, mul_comm, ← div_eq_mul_one_div]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a / b ≤ c ↔ a ≤ b * c
state_after: no goals
tactic: exact div_le_iff' h
Theorem: Turing.TM0.univ_supports
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
inst✝ : Inhabited Λ
M : Machine₀
⊢ Supports M Set.univ
state_after: no goals
tactic: constructor <;> intros <;> apply Set.mem_univ
Theorem: CompHaus.finiteCoproduct.ι_desc_apply
File: Mathlib/Topology/Category/CompHaus/Limits.lean

Proof steps:
state_before: α : Type w
inst✝ : Finite α
X : α → CompHaus
B : CompHaus
π : (a : α) → X a ⟶ B
a : α
⊢ ∀ (x : (forget CompHaus).obj (X a)), (desc X π) ((ι X a) x) = (π a) x
state_after: α : Type w
inst✝ : Finite α
X : α → CompHaus
B : CompHaus
π : (a : α) → X a ⟶ B
a : α
x : (forget CompHaus).obj (X a)
⊢ (desc X π) ((ι X a) x) = (π a) x
tactic: intro x
state_before: α : Type w
inst✝ : Finite α
X : α → CompHaus
B : CompHaus
π : (a : α) → X a ⟶ B
a : α
x : (forget CompHaus).obj (X a)
⊢ (desc X π) ((ι X a) x) = (π a) x
state_after: α : Type w
inst✝ : Finite α
X : α → CompHaus
B : CompHaus
π : (a : α) → X a ⟶ B
a : α
x : (forget CompHaus).obj (X a)
⊢ (ι X a ≫ desc X π) x = (π a) x
tactic: change (ι X a ≫ desc X π) _ = _
state_before: α : Type w
inst✝ : Finite α
X : α → CompHaus
B : CompHaus
π : (a : α) → X a ⟶ B
a : α
x : (forget CompHaus).obj (X a)
⊢ (ι X a ≫ desc X π) x = (π a) x
state_after: no goals
tactic: simp only [ι_desc]
Theorem: AList.lookup_insert
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
⊢ lookup a (insert a b s) = some b
state_after: no goals
tactic: simp only [lookup, insert, dlookup_kinsert]
Theorem: Topology.IsScott.closure_singleton
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ {a} ⊆ Iic a
state_after: no goals
tactic: rw [singleton_subset_iff, mem_Iic]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ Iic a ≤ closure {a}
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ ↑(lowerClosure {a}) ≤ closure {a}
tactic: rw [← LowerSet.coe_Iic, ← lowerClosure_singleton]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : IsScott α
s : Set α
a : α
⊢ ↑(lowerClosure {a}) ≤ closure {a}
state_after: no goals
tactic: apply lowerClosure_subset_closure
Theorem: Turing.Tape.write_mk'
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
a b : Γ
L R : ListBlank Γ
⊢ write b (mk' L (ListBlank.cons a R)) = mk' L (ListBlank.cons b R)
state_after: no goals
tactic: simp only [Tape.write, Tape.mk', ListBlank.head_cons, ListBlank.tail_cons, eq_self_iff_true,
    and_self_iff]
Theorem: AdicCompletion.sum_of
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

Proof steps:
state_before: R : Type u_1
inst✝¹¹ : CommRing R
I : Ideal R
M✝ : Type u_2
inst✝¹⁰ : AddCommGroup M✝
inst✝⁹ : Module R M✝
N : Type u_3
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
P : Type u_4
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R P
T : Type u_5
inst✝⁴ : AddCommGroup T
inst✝³ : Module (AdicCompletion I R) T
ι : Type u_6
inst✝² : DecidableEq ι
M : ι → Type u_7
inst✝¹ : (i : ι) → AddCommGroup (M i)
inst✝ : (i : ι) → Module R (M i)
j : ι
x : AdicCompletion I (M j)
⊢ (sum I M) ((DirectSum.of (fun i => AdicCompletion I (M i)) j) x) = (map I (lof R ι M j)) x
state_after: R : Type u_1
inst✝¹¹ : CommRing R
I : Ideal R
M✝ : Type u_2
inst✝¹⁰ : AddCommGroup M✝
inst✝⁹ : Module R M✝
N : Type u_3
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
P : Type u_4
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R P
T : Type u_5
inst✝⁴ : AddCommGroup T
inst✝³ : Module (AdicCompletion I R) T
ι : Type u_6
inst✝² : DecidableEq ι
M : ι → Type u_7
inst✝¹ : (i : ι) → AddCommGroup (M i)
inst✝ : (i : ι) → Module R (M i)
j : ι
x : AdicCompletion I (M j)
⊢ (sum I M) ((lof R ι (fun i => AdicCompletion I (M i)) j) x) = (map I (lof R ι M j)) x
tactic: rw [← lof_eq_of R]
state_before: R : Type u_1
inst✝¹¹ : CommRing R
I : Ideal R
M✝ : Type u_2
inst✝¹⁰ : AddCommGroup M✝
inst✝⁹ : Module R M✝
N : Type u_3
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R N
P : Type u_4
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R P
T : Type u_5
inst✝⁴ : AddCommGroup T
inst✝³ : Module (AdicCompletion I R) T
ι : Type u_6
inst✝² : DecidableEq ι
M : ι → Type u_7
inst✝¹ : (i : ι) → AddCommGroup (M i)
inst✝ : (i : ι) → Module R (M i)
j : ι
x : AdicCompletion I (M j)
⊢ (sum I M) ((lof R ι (fun i => AdicCompletion I (M i)) j) x) = (map I (lof R ι M j)) x
state_after: no goals
tactic: apply sum_lof
Theorem: CompositionSeries.toList_sorted
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (toList s).length
h : i < j
⊢ (toList s).get i < (toList s).get j
state_after: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (toList s).length
h : i < j
⊢ (List.ofFn s.toFun).get i < (List.ofFn s.toFun).get j
tactic: dsimp only [RelSeries.toList]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (toList s).length
h : i < j
⊢ (List.ofFn s.toFun).get i < (List.ofFn s.toFun).get j
state_after: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (toList s).length
h : i < j
⊢ s.toFun (Fin.cast ⋯ i) < s.toFun (Fin.cast ⋯ j)
tactic: rw [List.get_ofFn, List.get_ofFn]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i j : Fin (toList s).length
h : i < j
⊢ s.toFun (Fin.cast ⋯ i) < s.toFun (Fin.cast ⋯ j)
state_after: no goals
tactic: exact s.strictMono h
Theorem: Cardinal.eq_aleph_of_eq_card_ord
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
⊢ ∃ a, (aleph a).ord = o
state_after: case intro
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ∃ a, (aleph a).ord = o
tactic: cases' eq_aleph'_of_eq_card_ord ho with a ha
state_before: case intro
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ∃ a, (aleph a).ord = o
state_after: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph (a - ω)).ord = o
tactic: use a - ω
state_before: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph (a - ω)).ord = o
state_after: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph' (ω + (a - ω))).ord = o
tactic: unfold aleph
state_before: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ (aleph' (ω + (a - ω))).ord = o
state_after: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ω ≤ a
tactic: rwa [Ordinal.add_sub_cancel_of_le]
state_before: case h
o : Ordinal.{u_1}
ho : o.card.ord = o
ho' : ω ≤ o
a : Ordinal.{u_1}
ha : (aleph' a).ord = o
⊢ ω ≤ a
state_after: no goals
tactic: rwa [← aleph0_le_aleph', ← ord_le_ord, ha, ord_aleph0]
Theorem: Complex.log_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: ⊢ log I = ↑π / 2 * I
state_after: no goals
tactic: simp [log]
Theorem: CategoryTheory.Limits.WalkingParallelPairHom.comp_id
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: X Y : WalkingParallelPair
f : WalkingParallelPairHom X Y
⊢ f.comp (id Y) = f
state_after: no goals
tactic: cases f <;> rfl
Theorem: _private.Mathlib.RingTheory.WittVector.Teichmuller.0.WittVector.teichmuller_mul_aux₁
File: Mathlib/RingTheory/WittVector/Teichmuller.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
⊢ teichmullerFun p (x * y) = teichmullerFun p x * teichmullerFun p y
state_after: case a
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
⊢ ghostMap (teichmullerFun p (x * y)) = ghostMap (teichmullerFun p x * teichmullerFun p y)
tactic: apply (ghostMap.bijective_of_invertible p (MvPolynomial R ℚ)).1
state_before: case a
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
⊢ ghostMap (teichmullerFun p (x * y)) = ghostMap (teichmullerFun p x * teichmullerFun p y)
state_after: case a
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
⊢ ghostMap (teichmullerFun p (x * y)) = ghostMap (teichmullerFun p x) * ghostMap (teichmullerFun p y)
tactic: rw [RingHom.map_mul]
state_before: case a
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
⊢ ghostMap (teichmullerFun p (x * y)) = ghostMap (teichmullerFun p x) * ghostMap (teichmullerFun p y)
state_after: case a.h
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
n : ℕ
⊢ ghostMap (teichmullerFun p (x * y)) n = (ghostMap (teichmullerFun p x) * ghostMap (teichmullerFun p y)) n
tactic: ext1 n
state_before: case a.h
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x y : MvPolynomial R ℚ
n : ℕ
⊢ ghostMap (teichmullerFun p (x * y)) n = (ghostMap (teichmullerFun p x) * ghostMap (teichmullerFun p y)) n
state_after: no goals
tactic: simp only [Pi.mul_apply, ghostMap_apply, ghostComponent_teichmullerFun, mul_pow]
Theorem: IsSMulRegular.of_smul
File: Mathlib/Algebra/Regular/SMul.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : ((fun m => a • m) ∘ fun x => s • x) c = ((fun m => a • m) ∘ fun x => s • x) d
⊢ c = d
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : a • s • c = a • s • d
⊢ c = d
tactic: dsimp only [Function.comp_def] at cd
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : a • s • c = a • s • d
⊢ c = d
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : (a • s) • c = (a • s) • d
⊢ c = d
tactic: rw [← smul_assoc, ← smul_assoc] at cd
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b : R
s : S
inst✝³ : SMul R M
inst✝² : SMul R S
inst✝¹ : SMul S M
inst✝ : IsScalarTower R S M
a : R
ab : IsSMulRegular M (a • s)
c d : M
cd : (a • s) • c = (a • s) • d
⊢ c = d
state_after: no goals
tactic: exact ab cd
Theorem: zero_sub_add_zero_sub_rev
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ 1 / a * (1 / b) = 1 / (b * a)
state_after: no goals
tactic: simp