ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DFinsupp.mk_add
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (mk s (x + y)) i = (mk s x + mk s y) i
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (x + y) ⟨i, H⟩ else 0) = (if H : i ∈ s then x ⟨i, H⟩ else 0) + if H : i ∈ s then y ⟨i, H⟩ else 0
tactic: simp only [add_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (x + y) ⟨i, H⟩ else 0) = (if H : i ∈ s then x ⟨i, H⟩ else 0) + if H : i ∈ s then y ⟨i, H⟩ else 0
state_after: no goals
tactic: split_ifs <;> [rfl; rw [zero_add]]
Theorem: Zspan.span_top
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

Proof steps:
state_before: E : Type u_1
ι : Type u_2
K : Type u_3
inst✝² : NormedLinearOrderedField K
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace K E
b : Basis ι K E
⊢ span K ↑(span ℤ (Set.range ⇑b)) = ⊤
state_after: no goals
tactic: simp [span_span_of_tower]
Theorem: Monoid.CoprodI.Word.mem_smul_iff_of_ne
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
m₁ : M i
m₂ : M j
w : Word M
⊢ ⟨i, m₁⟩ ∈ (of m₂ • w).toList ↔ ⟨i, m₁⟩ ∈ w.toList
state_after: no goals
tactic: simp [mem_smul_iff, *]
Theorem: associated_one_of_associated_mul_one
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
u : αˣ
h : a * b * ↑u = 1
⊢ a * (b * ↑u) = 1
state_after: no goals
tactic: simpa [mul_assoc] using h
Theorem: Path.Homotopy.reflTransSymmAux_mem_I
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
⊢ reflTransSymmAux x ∈ I
state_after: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
⊢ (if ↑x.2 ≤ 1 / 2 then ↑x.1 * 2 * ↑x.2 else ↑x.1 * (2 - 2 * ↑x.2)) ∈ I
tactic: dsimp only [reflTransSymmAux]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
⊢ (if ↑x.2 ≤ 1 / 2 then ↑x.1 * 2 * ↑x.2 else ↑x.1 * (2 - 2 * ↑x.2)) ∈ I
state_after: case pos
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
h✝ : ↑x.2 ≤ 1 / 2
⊢ ↑x.1 * 2 * ↑x.2 ∈ I

case neg
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
x : ↑I × ↑I
h✝ : ¬↑x.2 ≤ 1 / 2
⊢ ↑x.1 * (2 - 2 * ↑x.2) ∈ I
tactic: split_ifs
Theorem: isLUB_prod
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
⊢ IsLUB s p ↔ IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2
state_after: case refine_1
α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB s p
a : α
ha : a ∈ upperBounds (Prod.fst '' s)
⊢ p.1 ≤ a

case refine_2
α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB s p
a : β
ha : a ∈ upperBounds (Prod.snd '' s)
⊢ p.2 ≤ a

case refine_3
α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2
⊢ p ∈ upperBounds s

case refine_4
α✝ : Type u
β✝ : Type v
γ : Type w
ι : Sort x
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set (α × β)
p : α × β
H : IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2
⊢ p ∈ lowerBounds (upperBounds s)
tactic: refine
    ⟨fun H =>
      ⟨⟨monotone_fst.mem_upperBounds_image H.1, fun a ha => ?_⟩,
        ⟨monotone_snd.mem_upperBounds_image H.1, fun a ha => ?_⟩⟩,
      fun H => ⟨?_, ?_⟩⟩
Theorem: EuclideanDomain.xgcdAux_P
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b r r' s t s' t' : R
p : EuclideanDomain.P a b (r, s, t)
p' : EuclideanDomain.P a b (r', s', t')
⊢ EuclideanDomain.P a b (xgcdAux r s t r' s' t')
state_after: no goals
tactic: induction r, r' using GCD.induction generalizing s t s' t' with
  | H0 n => simpa only [xgcd_zero_left]
  | H1 _ _ h IH =>
    rw [xgcdAux_rec h]
    refine IH ?_ p
    unfold P at p p' ⊢
    dsimp
    rw [mul_sub, mul_sub, add_sub, sub_add_eq_add_sub, ← p', sub_sub, mul_comm _ s, ← mul_assoc,
      mul_comm _ t, ← mul_assoc, ← add_mul, ← p, mod_eq_sub_mul_div]
Theorem: LiouvilleWith.rat_sub_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (↑r - x) ↔ LiouvilleWith p x
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: nhdsWithin_prod
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α✝
α : Type u_5
inst✝¹ : TopologicalSpace α
β : Type u_6
inst✝ : TopologicalSpace β
s u : Set α
t v : Set β
a : α
b : β
hu : u ∈ 𝓝[s] a
hv : v ∈ 𝓝[t] b
⊢ u ×ˢ v ∈ 𝓝[s ×ˢ t] (a, b)
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α✝
α : Type u_5
inst✝¹ : TopologicalSpace α
β : Type u_6
inst✝ : TopologicalSpace β
s u : Set α
t v : Set β
a : α
b : β
hu : u ∈ 𝓝[s] a
hv : v ∈ 𝓝[t] b
⊢ u ×ˢ v ∈ 𝓝[s] a ×ˢ 𝓝[t] b
tactic: rw [nhdsWithin_prod_eq]
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : TopologicalSpace α✝
α : Type u_5
inst✝¹ : TopologicalSpace α
β : Type u_6
inst✝ : TopologicalSpace β
s u : Set α
t v : Set β
a : α
b : β
hu : u ∈ 𝓝[s] a
hv : v ∈ 𝓝[t] b
⊢ u ×ˢ v ∈ 𝓝[s] a ×ˢ 𝓝[t] b
state_after: no goals
tactic: exact prod_mem_prod hu hv
Theorem: GenContFract.terminatedAt_iff_partNum_none
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

Proof steps:
state_before: α : Type u_1
g : GenContFract α
n : ℕ
⊢ g.TerminatedAt n ↔ g.partNums.get? n = none
state_after: no goals
tactic: rw [terminatedAt_iff_s_none, partNum_none_iff_s_none]
Theorem: strictMono_of_hasDerivAt_pos
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f f' : ℝ → ℝ
hf : ∀ (x : ℝ), HasDerivAt f (f' x) x
hf' : ∀ (x : ℝ), 0 < f' x
x : ℝ
⊢ 0 < deriv f x
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f f' : ℝ → ℝ
hf : ∀ (x : ℝ), HasDerivAt f (f' x) x
hf' : ∀ (x : ℝ), 0 < f' x
x : ℝ
⊢ 0 < f' x
tactic: rw [(hf _).deriv]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f f' : ℝ → ℝ
hf : ∀ (x : ℝ), HasDerivAt f (f' x) x
hf' : ∀ (x : ℝ), 0 < f' x
x : ℝ
⊢ 0 < f' x
state_after: no goals
tactic: exact hf' _
Theorem: ENNReal.ofReal_tsum_of_nonneg
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ
hf_nonneg : ∀ (n : α), 0 ≤ f n
hf : Summable f
⊢ ENNReal.ofReal (∑' (n : α), f n) = ∑' (n : α), ENNReal.ofReal (f n)
state_after: no goals
tactic: simp_rw [ENNReal.ofReal, ENNReal.tsum_coe_eq (NNReal.hasSum_real_toNNReal_of_nonneg hf_nonneg hf)]
Theorem: Order.Ideal.isProper_of_not_mem
File: Mathlib/Order/Ideal.lean

Proof steps:
state_before: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
⊢ False
state_after: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ univ
⊢ False
tactic: have := mem_univ p
state_before: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ univ
⊢ False
state_after: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ ↑I
⊢ False
tactic: rw [← hp] at this
state_before: P : Type u_1
inst✝ : LE P
I✝ J s t : Ideal P
x y : P
I : Ideal P
p : P
nmem : p ∉ I
hp : ↑I = univ
this : p ∈ ↑I
⊢ False
state_after: no goals
tactic: exact nmem this
Theorem: CategoryTheory.Functor.mapHomotopyEquiv_homotopyHomInvId
File: Mathlib/Algebra/Homology/Homotopy.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{?u.288867, u_2} W
inst✝¹ : Preadditive W
F : V ⥤ W
inst✝ : F.Additive
h : HomotopyEquiv C D
⊢ Homotopy ((F.mapHomologicalComplex c).map h.hom ≫ (F.mapHomologicalComplex c).map h.inv)
    (𝟙 ((F.mapHomologicalComplex c).obj C))
state_after: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{?u.288867, u_2} W
inst✝¹ : Preadditive W
F : V ⥤ W
inst✝ : F.Additive
h : HomotopyEquiv C D
⊢ Homotopy ((F.mapHomologicalComplex c).map (h.hom ≫ h.inv)) ((F.mapHomologicalComplex c).map (𝟙 C))
tactic: rw [← (F.mapHomologicalComplex c).map_comp, ← (F.mapHomologicalComplex c).map_id]
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{?u.288867, u_2} W
inst✝¹ : Preadditive W
F : V ⥤ W
inst✝ : F.Additive
h : HomotopyEquiv C D
⊢ Homotopy ((F.mapHomologicalComplex c).map (h.hom ≫ h.inv)) ((F.mapHomologicalComplex c).map (𝟙 C))
state_after: no goals
tactic: exact F.mapHomotopy h.homotopyHomInvId
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{?u.288867, u_2} W
inst✝¹ : Preadditive W
F : V ⥤ W
inst✝ : F.Additive
h : HomotopyEquiv C D
⊢ Homotopy ((F.mapHomologicalComplex c).map h.inv ≫ (F.mapHomologicalComplex c).map h.hom)
    (𝟙 ((F.mapHomologicalComplex c).obj D))
state_after: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{?u.288867, u_2} W
inst✝¹ : Preadditive W
F : V ⥤ W
inst✝ : F.Additive
h : HomotopyEquiv C D
⊢ Homotopy ((F.mapHomologicalComplex c).map (h.inv ≫ h.hom)) ((F.mapHomologicalComplex c).map (𝟙 D))
tactic: rw [← (F.mapHomologicalComplex c).map_comp, ← (F.mapHomologicalComplex c).map_id]
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{?u.288867, u_2} W
inst✝¹ : Preadditive W
F : V ⥤ W
inst✝ : F.Additive
h : HomotopyEquiv C D
⊢ Homotopy ((F.mapHomologicalComplex c).map (h.inv ≫ h.hom)) ((F.mapHomologicalComplex c).map (𝟙 D))
state_after: no goals
tactic: exact F.mapHomotopy h.homotopyInvHomId
Theorem: Nat.mul_eq_left
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
ha : a ≠ 0
⊢ a * b = a ↔ b = 1
state_after: no goals
tactic: simpa using Nat.mul_right_inj ha (c := 1)
Theorem: Nat.descFactorial_self
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: ⊢ descFactorial 0 0 = 0!
state_after: no goals
tactic: rw [descFactorial_zero, factorial_zero]
state_before: n : ℕ
⊢ n.succ.descFactorial n.succ = n.succ !
state_after: no goals
tactic: rw [succ_descFactorial_succ, descFactorial_self n, factorial_succ]
Theorem: MeasureTheory.Measure.dirac_unit_compProd_const
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ✝ : Measure α
κ η : Kernel α β
μ : Measure β
inst✝ : IsFiniteMeasure μ
⊢ dirac () ⊗ₘ Kernel.const Unit μ = map (Prod.mk ()) μ
state_after: no goals
tactic: rw [dirac_unit_compProd, Kernel.const_apply]
Theorem: Part.elim_toOption
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
⊢ a.toOption.elim b f = if h : a.Dom then f (a.get h) else b
state_after: case pos
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : a.Dom
⊢ a.toOption.elim b f = f (a.get h)

case neg
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
a : Part α
inst✝ : Decidable a.Dom
b : β
f : α → β
h : ¬a.Dom
⊢ a.toOption.elim b f = b
tactic: split_ifs with h
Theorem: Cardinal.mk_finset_of_fintype
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
inst✝ : Fintype α
⊢ #(Finset α) = 2 ^ Fintype.card α
state_after: no goals
tactic: simp [Pow.pow]
Theorem: CochainComplex.HomComplex.Cocycle.mem_iff
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
⊢ z ∈ cocycle F G n ↔ δ n m z = 0
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n : ℤ
z : Cochain F G n
⊢ z ∈ cocycle F G n ↔ δ n (n + 1) z = 0
tactic: subst hnm
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n : ℤ
z : Cochain F G n
⊢ z ∈ cocycle F G n ↔ δ n (n + 1) z = 0
state_after: no goals
tactic: rfl
Theorem: Option.map_comm
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f₁ : α → β
f₂ : α → γ
g₁ : β → δ
g₂ : γ → δ
h : g₁ ∘ f₁ = g₂ ∘ f₂
a : α
⊢ Option.map g₁ (Option.map f₁ (some a)) = Option.map g₂ (Option.map f₂ (some a))
state_after: no goals
tactic: rw [map_map, h, ← map_map]
Theorem: Mathlib.Meta.NormNum.isNat_natAbs_neg
File: Mathlib/Tactic/NormNum/Basic.lean

Proof steps:
state_before: a✝ : ℕ
⊢ (↑(Int.negOfNat a✝)).natAbs = ↑a✝
state_after: no goals
tactic: simp
Theorem: Polynomial.ne_zero_of_degree_ge_degree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hpq : p.degree ≤ q.degree
hp : p ≠ 0
⊢ p.degree ≠ ⊥
state_after: no goals
tactic: rwa [Ne, Polynomial.degree_eq_bot]
Theorem: EReal.inv_pos_of_pos_ne_top
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a : EReal
h : 0 < a
h' : a ≠ ⊤
⊢ 0 < a⁻¹
state_after: no goals
tactic: induction a with
  | h_bot => exact (not_lt_bot h).rec
  | h_real a =>  rw [← coe_inv a]; norm_cast at *; exact inv_pos_of_pos h
  | h_top => exact (h' (Eq.refl ⊤)).rec
Theorem: CategoryTheory.Limits.PullbackCone.mk_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
W : C
fst : W ⟶ X
snd : W ⟶ Y
eq : fst ≫ f = snd ≫ g
⊢ ∀ ⦃X_1 Y_1 : WalkingCospan⦄ (f_1 : X_1 ⟶ Y_1),
    ((Functor.const WalkingCospan).obj W).map f_1 ≫
        (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) Y_1 =
      (fun j => Option.casesOn j (fst ≫ f) fun j' => WalkingPair.casesOn j' fst snd) X_1 ≫ (cospan f g).map f_1
state_after: no goals
tactic: rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) j <;> cases j <;> dsimp <;> simp [eq]
Theorem: IsAddGroupHom.zero_ker_neg
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f (a * b⁻¹) = 1
⊢ f a = f b
state_after: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a * (f b)⁻¹ = 1
⊢ f a = f b
tactic: rw [hf.map_mul, hf.map_inv] at h
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a * (f b)⁻¹ = 1
⊢ f a = f b
state_after: no goals
tactic: rw [← inv_inv (f b), eq_inv_of_mul_eq_one_left h]
Theorem: LinearMap.toMatrix₂_mul
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁸ : CommSemiring R
inst✝¹⁷ : AddCommMonoid M₁
inst✝¹⁶ : Module R M₁
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : Module R M₂
inst✝¹³ : AddCommMonoid N₂
inst✝¹² : Module R N₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁✝ : Basis n R M₁
b₂✝ : Basis m R M₂
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : M₁ →ₗ[R] M₂ →ₗ[R] R
M : Matrix m m' R
⊢ (toMatrix₂ b₁ b₂) B * M = (toMatrix₂ b₁ b₂') (B.compl₂ ((toLin b₂' b₂) M))
state_after: no goals
tactic: rw [LinearMap.toMatrix₂_compl₂ b₁ b₂, toMatrix_toLin]
Theorem: CategoryTheory.right_unitality_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)
n : M
X : C
⊢ F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj 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)
n : M
X : C
this : (ρ_ (F.obj n)).hom.app X = (F.obj n ◁ F.ε ≫ F.μ n (𝟙_ M) ≫ F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))
tactic: have := congr_app (F.toLaxMonoidalFunctor.right_unitality n) X
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)
n : M
X : C
this : (ρ_ (F.obj n)).hom.app X = (F.obj n ◁ F.ε ≫ F.μ n (𝟙_ M) ≫ F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj 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)
n : M
X : C
this : 𝟙 ((F.obj n).obj X) = F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))
tactic: dsimp at this
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)
n : M
X : C
this : 𝟙 ((F.obj n).obj X) = F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (F.μ n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X = 𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))
state_after: no goals
tactic: simpa using this.symm
Theorem: FractionalIdeal.inv_le_comm
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
I J : FractionalIdeal A⁰ K
hI : I ≠ 0
hJ : J ≠ 0
⊢ I⁻¹ ≤ J ↔ J⁻¹ ≤ I
state_after: no goals
tactic: simpa using le_inv_comm (A := A) (K := K) (inv_ne_zero hI) (inv_ne_zero hJ)
Theorem: AlgebraicGeometry.sigmaMk_mk
File: Mathlib/AlgebraicGeometry/Limits.lean

Proof steps:
state_before: ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ (sigmaMk f) ⟨i, x⟩ = (Sigma.ι f i).val.base x
state_after: ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ ((TopCat.sigmaCofan fun x => (f x).toTopCat).inj i ≫
        (colimit.isoColimitCocone
              { cocone := TopCat.sigmaCofan fun x => (f x).toTopCat,
                isColimit := TopCat.sigmaCofanIsColimit fun x => (f x).toTopCat }).inv ≫
          (PreservesCoproduct.iso Scheme.forgetToTop f).symm.hom)
      x =
    (Scheme.forgetToTop.map (Sigma.ι f i)) x
tactic: show ((TopCat.sigmaCofan (fun x ↦ (f x).toTopCat)).inj i ≫
    (colimit.isoColimitCocone ⟨_, TopCat.sigmaCofanIsColimit _⟩).inv ≫ _) x =
      Scheme.forgetToTop.map (Sigma.ι f i) x
state_before: ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ ((TopCat.sigmaCofan fun x => (f x).toTopCat).inj i ≫
        (colimit.isoColimitCocone
              { cocone := TopCat.sigmaCofan fun x => (f x).toTopCat,
                isColimit := TopCat.sigmaCofanIsColimit fun x => (f x).toTopCat }).inv ≫
          (PreservesCoproduct.iso Scheme.forgetToTop f).symm.hom)
      x =
    (Scheme.forgetToTop.map (Sigma.ι f i)) x
state_after: case e_a
ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ (TopCat.sigmaCofan fun x => (f x).toTopCat).inj i ≫
      (colimit.isoColimitCocone
            { cocone := TopCat.sigmaCofan fun x => (f x).toTopCat,
              isColimit := TopCat.sigmaCofanIsColimit fun x => (f x).toTopCat }).inv ≫
        (PreservesCoproduct.iso Scheme.forgetToTop f).symm.hom =
    Scheme.forgetToTop.map (Sigma.ι f i)
tactic: congr 1
state_before: case e_a
ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ (TopCat.sigmaCofan fun x => (f x).toTopCat).inj i ≫
      (colimit.isoColimitCocone
            { cocone := TopCat.sigmaCofan fun x => (f x).toTopCat,
              isColimit := TopCat.sigmaCofanIsColimit fun x => (f x).toTopCat }).inv ≫
        (PreservesCoproduct.iso Scheme.forgetToTop f).symm.hom =
    Scheme.forgetToTop.map (Sigma.ι f i)
state_after: case e_a
ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ colimit.ι (Discrete.functor fun x => (f x).toTopCat) { as := i } ≫
      (PreservesCoproduct.iso Scheme.forgetToTop f).symm.hom =
    Scheme.forgetToTop.map (Sigma.ι f i)
tactic: refine (colimit.isoColimitCocone_ι_inv_assoc ⟨_, TopCat.sigmaCofanIsColimit _⟩ _ _).trans ?_
state_before: case e_a
ι : Type u
f : ι → Scheme
i : ι
x : ↑↑(f i).toPresheafedSpace
⊢ colimit.ι (Discrete.functor fun x => (f x).toTopCat) { as := i } ≫
      (PreservesCoproduct.iso Scheme.forgetToTop f).symm.hom =
    Scheme.forgetToTop.map (Sigma.ι f i)
state_after: no goals
tactic: exact ι_comp_sigmaComparison Scheme.forgetToTop _ _