ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Localization.r_iff_exists
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (r S) x y ↔ ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1)
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (r' S) x y ↔ ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1)
tactic: rw [r_eq_r' S]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
x y : M × ↥S
⊢ (r' S) x y ↔ ∃ c, ↑c * (↑y.2 * x.1) = ↑c * (↑x.2 * y.1)
state_after: no goals
tactic: rfl
Theorem: PowerSeries.coeff_coe_trunc_of_lt
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n m : ℕ
f : R⟦X⟧
h : n < m
⊢ (coeff R n) ↑(trunc m f) = (coeff R n) f
state_after: no goals
tactic: rwa [coeff_coe, coeff_trunc, if_pos]
Theorem: CommMon_.trivial_mul
File: Mathlib/CategoryTheory/Monoidal/CommMon_.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ (β_ __src✝.X __src✝.X).hom ≫ __src✝.mul = __src✝.mul
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ (β_ (𝟙_ C) (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom = (λ_ (𝟙_ C)).hom
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ (β_ (𝟙_ C) (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom = (λ_ (𝟙_ C)).hom
state_after: no goals
tactic: rw [braiding_leftUnitor, unitors_equal]
Theorem: FreeAbelianGroup.support_neg
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
a : FreeAbelianGroup X
⊢ (-a).support = a.support
state_after: no goals
tactic: simp only [support, AddMonoidHom.map_neg, Finsupp.support_neg]
Theorem: CategoryTheory.Functor.pi'_eval
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)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f : (i : I) → A ⥤ C i
i : I
⊢ pi' f ⋙ Pi.eval C i = f i
state_after: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f : (i : I) → A ⥤ C i
i : I
⊢ autoParam (∀ (X Y : A) (f_1 : X ⟶ Y), (pi' f ⋙ Pi.eval C i).map f_1 = eqToHom ⋯ ≫ (f i).map f_1 ≫ eqToHom ⋯) _auto✝

case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f : (i : I) → A ⥤ C i
i : I
⊢ ∀ (X : A), (pi' f ⋙ Pi.eval C i).obj X = (f i).obj X
tactic: apply Functor.ext
Theorem: Pell.y_mul_dvd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ yn a1 (n * (k + 1))
state_after: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ xn a1 (n * k) * yn a1 n + yn a1 (n * k) * xn a1 n
tactic: rw [Nat.mul_succ, yn_add]
state_before: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ xn a1 (n * k) * yn a1 n + yn a1 (n * k) * xn a1 n
state_after: no goals
tactic: exact dvd_add (dvd_mul_left _ _) ((y_mul_dvd _ k).mul_right _)
Theorem: Option.injective_iff
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : Option α → β
⊢ Injective f ↔ (Injective fun x => f (some x)) ∧ ∀ (x : α), ¬f (some x) = f none
state_after: α : Type u_1
β : Type u_2
f : Option α → β
⊢ ((Injective fun x => f (some x)) ∧ ∀ (x : α), ¬f (some x) = f none) → Injective f
tactic: refine
    ⟨fun hf => ⟨hf.comp (Option.some_injective _), fun x => hf.ne <| Option.some_ne_none _⟩, ?_⟩
state_before: α : Type u_1
β : Type u_2
f : Option α → β
⊢ ((Injective fun x => f (some x)) ∧ ∀ (x : α), ¬f (some x) = f none) → Injective f
state_after: case intro.none.none
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
hab : f none = f none
⊢ none = none

case intro.none.some
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
b : α
hab : f none = f (some b)
⊢ none = some b

case intro.some.none
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
a : α
hab : f (some a) = f none
⊢ some a = none

case intro.some.some
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
a b : α
hab : f (some a) = f (some b)
⊢ some a = some b
tactic: rintro ⟨h_some, h_none⟩ (_ | a) (_ | b) hab
state_before: case intro.none.none
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
hab : f none = f none
⊢ none = none

case intro.none.some
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
b : α
hab : f none = f (some b)
⊢ none = some b

case intro.some.none
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
a : α
hab : f (some a) = f none
⊢ some a = none

case intro.some.some
α : Type u_1
β : Type u_2
f : Option α → β
h_some : Injective fun x => f (some x)
h_none : ∀ (x : α), ¬f (some x) = f none
a b : α
hab : f (some a) = f (some b)
⊢ some a = some b
state_after: no goals
tactic: exacts [rfl, (h_none _ hab.symm).elim, (h_none _ hab).elim, congr_arg some (h_some hab)]
Theorem: directedOn_range
File: Mathlib/Order/Directed.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
r r' s : α → α → Prop
f : ι → α
⊢ Directed r f ↔ DirectedOn r (Set.range f)
state_after: no goals
tactic: simp_rw [Directed, DirectedOn, Set.forall_mem_range, Set.exists_range_iff]
Theorem: Multiset.coe_inter
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
s t : List α
⊢ ↑s ∩ ↑t = ↑(s.bagInter t)
state_after: case a
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
s t : List α
a✝ : α
⊢ count a✝ (↑s ∩ ↑t) = count a✝ ↑(s.bagInter t)
tactic: ext
state_before: case a
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
s t : List α
a✝ : α
⊢ count a✝ (↑s ∩ ↑t) = count a✝ ↑(s.bagInter t)
state_after: no goals
tactic: simp
Theorem: List.sublistsAux_eq_array_foldl
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
⊢ sublistsAux = fun a r => (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r) 0).toList
state_after: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a r = (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r) 0).toList
tactic: funext a r
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a r = (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r) 0).toList
state_after: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList
tactic: simp only [sublistsAux, Array.foldl_eq_foldl_data, Array.mkEmpty]
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList
state_after: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
this : foldl (fun r l => r ++ [l, a :: l]) #[].toList r = (foldl (fun r l => (r.push l).push (a :: l)) #[] r).toList
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList
tactic: have := foldl_hom Array.toList (fun r l => (r.push l).push (a :: l))
    (fun (r : List (List α)) l => r ++ [l, a :: l]) r #[]
    (by simp)
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
this : foldl (fun r l => r ++ [l, a :: l]) #[].toList r = (foldl (fun r l => (r.push l).push (a :: l)) #[] r).toList
⊢ foldl (fun r l => r ++ [l, a :: l]) [] r = (foldl (fun r l => (r.push l).push (a :: l)) #[] (toArray r).data).toList
state_after: no goals
tactic: simpa using this
Theorem: MulEquiv.ofLeftInverse_symm_apply
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝¹ : Mul M
inst✝ : Mul N
S T : Subsemigroup M
f : M →ₙ* N
g : N → M
h : Function.LeftInverse g ⇑f
x : ↥f.srange
x' : M
hx' : f x' = ↑x
⊢ f (g ↑x) = ↑x
state_after: no goals
tactic: rw [← hx', h x']
Theorem: Ordinal.bsup_eq_bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r r' : ι → ι → Prop
inst✝¹ : IsWellOrder ι r
inst✝ : IsWellOrder ι r'
f : ι → Ordinal.{max u v}
⊢ (type r).bsup (bfamilyOfFamily' r f) = (type r').bsup (bfamilyOfFamily' r' f)
state_after: no goals
tactic: rw [bsup_eq_sup', bsup_eq_sup']
Theorem: Real.diam_Ioc
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
a b : ℝ
h : a ≤ b
⊢ Metric.diam (Ioc a b) = b - a
state_after: no goals
tactic: simp [Metric.diam, ENNReal.toReal_ofReal (sub_nonneg.2 h)]
Theorem: Finset.fold_hom
File: Mathlib/Data/Finset/Fold.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
op' : γ → γ → γ
inst✝¹ : Std.Commutative op'
inst✝ : Std.Associative op'
m : β → γ
hm : ∀ (x y : β), m (op x y) = op' (m x) (m y)
⊢ fold op' (m b) (fun x => m (f x)) s = m (fold op b f s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
op' : γ → γ → γ
inst✝¹ : Std.Commutative op'
inst✝ : Std.Associative op'
m : β → γ
hm : ∀ (x y : β), m (op x y) = op' (m x) (m y)
⊢ Multiset.fold op' (m b) (Multiset.map (fun x => m (f x)) s.val) = Multiset.fold op' (m b) (Multiset.map (m ∘ f) s.val)
tactic: rw [fold, fold, ← Multiset.fold_hom op hm, Multiset.map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
op' : γ → γ → γ
inst✝¹ : Std.Commutative op'
inst✝ : Std.Associative op'
m : β → γ
hm : ∀ (x y : β), m (op x y) = op' (m x) (m y)
⊢ Multiset.fold op' (m b) (Multiset.map (fun x => m (f x)) s.val) = Multiset.fold op' (m b) (Multiset.map (m ∘ f) s.val)
state_after: no goals
tactic: simp only [Function.comp_apply]
Theorem: Num.cast_succ'
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddMonoidWithOne α
n : Num
⊢ ↑n.succ' = ↑n + 1
state_after: no goals
tactic: rw [← PosNum.cast_to_nat, succ'_to_nat, Nat.cast_add_one, cast_to_nat]
Theorem: RingHom.ker_fg_of_localizationSpan
File: Mathlib/RingTheory/Localization/Finiteness.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
⊢ (ker f).FG
state_after: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
⊢ ∀ (g : ↑t), (Ideal.map (algebraMap R (Localization.Away ↑g)) (ker f)).FG
tactic: apply Ideal.fg_of_localizationSpan t ht
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
⊢ ∀ (g : ↑t), (Ideal.map (algebraMap R (Localization.Away ↑g)) (ker f)).FG
state_after: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
g : ↑t
⊢ (Ideal.map (algebraMap R (Localization.Away ↑g)) (ker f)).FG
tactic: intro g
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
g : ↑t
⊢ (Ideal.map (algebraMap R (Localization.Away ↑g)) (ker f)).FG
state_after: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
g : ↑t
⊢ (ker (IsLocalization.map (Localization.Away (f ↑g)) f ⋯)).FG
tactic: rw [← IsLocalization.ker_map (Localization.Away (f g.val)) f (Submonoid.map_powers f g.val)]
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
t : Set R
ht : Ideal.span t = ⊤
H : ∀ (g : ↑t), (ker (Localization.awayMap f ↑g)).FG
g : ↑t
⊢ (ker (IsLocalization.map (Localization.Away (f ↑g)) f ⋯)).FG
state_after: no goals
tactic: exact H g
Theorem: Real.sqrt_pos
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
⊢ √x ≤ 0 ↔ √x = 0
state_after: no goals
tactic: simp [le_antisymm_iff, sqrt_nonneg]
Theorem: MeasureTheory.supermartingale_of_condexp_sub_nonneg_nat
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f i - f (i + 1)|↑𝒢 i]
⊢ Supermartingale f 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f i - f (i + 1)|↑𝒢 i]
⊢ Supermartingale (- -f) 𝒢 μ
tactic: rw [← neg_neg f]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f i - f (i + 1)|↑𝒢 i]
⊢ Supermartingale (- -f) 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f i - f (i + 1)|↑𝒢 i]
⊢ ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[(-f) (i + 1) - (-f) i|↑𝒢 i]
tactic: refine (submartingale_of_condexp_sub_nonneg_nat hadp.neg (fun i => (hint i).neg) ?_).neg
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f i - f (i + 1)|↑𝒢 i]
⊢ ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[(-f) (i + 1) - (-f) i|↑𝒢 i]
state_after: no goals
tactic: simpa only [Pi.zero_apply, Pi.neg_apply, neg_sub_neg]
Theorem: Matrix.conjTranspose_tsum
File: Mathlib/Topology/Instances/Matrix.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
p : Type u_6
S : Type u_7
R : Type u_8
m' : l → Type u_9
n' : l → Type u_10
inst✝⁶ : Semiring α
inst✝⁵ : AddCommMonoid R
inst✝⁴ : TopologicalSpace R
inst✝³ : Module α R
inst✝² : StarAddMonoid R
inst✝¹ : ContinuousStar R
inst✝ : T2Space R
f : X → Matrix m n R
⊢ (∑' (x : X), f x)ᴴ = ∑' (x : X), (f x)ᴴ
state_after: case pos
X : Type u_1
α : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
p : Type u_6
S : Type u_7
R : Type u_8
m' : l → Type u_9
n' : l → Type u_10
inst✝⁶ : Semiring α
inst✝⁵ : AddCommMonoid R
inst✝⁴ : TopologicalSpace R
inst✝³ : Module α R
inst✝² : StarAddMonoid R
inst✝¹ : ContinuousStar R
inst✝ : T2Space R
f : X → Matrix m n R
hf : Summable f
⊢ (∑' (x : X), f x)ᴴ = ∑' (x : X), (f x)ᴴ

case neg
X : Type u_1
α : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
p : Type u_6
S : Type u_7
R : Type u_8
m' : l → Type u_9
n' : l → Type u_10
inst✝⁶ : Semiring α
inst✝⁵ : AddCommMonoid R
inst✝⁴ : TopologicalSpace R
inst✝³ : Module α R
inst✝² : StarAddMonoid R
inst✝¹ : ContinuousStar R
inst✝ : T2Space R
f : X → Matrix m n R
hf : ¬Summable f
⊢ (∑' (x : X), f x)ᴴ = ∑' (x : X), (f x)ᴴ
tactic: by_cases hf : Summable f
Theorem: AlgebraicGeometry.Scheme.OpenCover.glued_cover_cocycle_snd
File: Mathlib/AlgebraicGeometry/Gluing.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
x y z : 𝒰.J
⊢ 𝒰.gluedCoverT' x y z ≫
      𝒰.gluedCoverT' y z x ≫
        𝒰.gluedCoverT' z x y ≫ pullback.snd (pullback.fst (𝒰.map x) (𝒰.map y)) (pullback.fst (𝒰.map x) (𝒰.map z)) =
    pullback.snd (pullback.fst (𝒰.map x) (𝒰.map y)) (pullback.fst (𝒰.map x) (𝒰.map z))
state_after: no goals
tactic: apply pullback.hom_ext <;> simp [pullback.condition]
Theorem: ContinuousLinearEquiv.hasSum'
File: Mathlib/Topology/Algebra/InfiniteSum/Module.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
κ : Type u_6
R : Type u_7
R₂ : Type u_8
M : Type u_9
M₂ : Type u_10
inst✝⁹ : Semiring R
inst✝⁸ : Semiring R₂
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R₂ M₂
inst✝³ : TopologicalSpace M
inst✝² : TopologicalSpace M₂
σ : R →+* R₂
σ' : R₂ →+* R
inst✝¹ : RingHomInvPair σ σ'
inst✝ : RingHomInvPair σ' σ
f : ι → M
e : M ≃SL[σ] M₂
x : M
⊢ HasSum (fun b => e (f b)) (e x) ↔ HasSum f x
state_after: no goals
tactic: rw [e.hasSum, ContinuousLinearEquiv.symm_apply_apply]
Theorem: MultilinearMap.toLinearMap_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 : Fin n.succ) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin n.succ) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
inst✝ : DecidableEq ι
m : (i : ι) → M₁ i
i : ι
x y : M₁ i
⊢ (fun x => f (update m i x)) (x + y) = (fun x => f (update m i x)) x + (fun x => f (update m i x)) y
state_after: no goals
tactic: simp
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 : Fin n.succ) → AddCommMonoid (M i)
inst✝⁹ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
inst✝⁶ : AddCommMonoid M'
inst✝⁵ : (i : Fin n.succ) → Module R (M i)
inst✝⁴ : (i : ι) → Module R (M₁ i)
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M'
f f' : MultilinearMap R M₁ M₂
inst✝ : DecidableEq ι
m : (i : ι) → M₁ i
i : ι
c : R
x : M₁ i
⊢ { toFun := fun x => f (update m i x), map_add' := ⋯ }.toFun (c • x) =
    (RingHom.id R) c • { toFun := fun x => f (update m i x), map_add' := ⋯ }.toFun x
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShortComplex.ShortExact.singleTriangleIso_inv_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: CategoryTheory.Preadditive.IsIso.comp_right_eq_zero
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
P Q R : C
f f' : P ⟶ Q
g g' : Q ⟶ R
inst✝ : IsIso g
⊢ f ≫ g = 0 ↔ f = 0
state_after: no goals
tactic: rw [← IsIso.eq_comp_inv, Limits.zero_comp]
Theorem: two_nsmul
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
⊢ a ^ 2 = a * a
state_after: no goals
tactic: rw [pow_succ, pow_one]
Theorem: List.lt_findIdx_of_not
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
h2 : ∀ (j : ℕ) (hji : j ≤ i), ¬p (xs.get ⟨j, ⋯⟩) = true
⊢ i < findIdx p xs
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
h2 : ∀ (j : ℕ) (hji : j ≤ i), ¬p (xs.get ⟨j, ⋯⟩) = true
f : findIdx p xs ≤ i
⊢ False
tactic: by_contra! f
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
i : ℕ
h : i < xs.length
h2 : ∀ (j : ℕ) (hji : j ≤ i), ¬p (xs.get ⟨j, ⋯⟩) = true
f : findIdx p xs ≤ i
⊢ False
state_after: no goals
tactic: exact absurd (@findIdx_get _ p xs (f.trans_lt h)) (h2 (xs.findIdx p) f)