ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HomologicalComplex.eqToHom_f
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ : HomologicalComplex V c
h : C₁ = C₂
n : ι
⊢ (eqToHom h).f n = eqToHom ⋯
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ : HomologicalComplex V c
n : ι
⊢ (eqToHom ⋯).f n = eqToHom ⋯
tactic: subst h
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ : HomologicalComplex V c
n : ι
⊢ (eqToHom ⋯).f n = eqToHom ⋯
state_after: no goals
tactic: rfl
Theorem: AddConstMapClass.map_add_nat
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddMonoidWithOne G
inst✝¹ : AddMonoidWithOne H
inst✝ : AddConstMapClass F G H 1 1
f : F
x : G
n : ℕ
⊢ f (x + ↑n) = f x + ↑n
state_after: no goals
tactic: simp
Theorem: IsPrimitiveRoot.norm_toInteger_sub_one_of_prime_ne_two'
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
h : p ≠ 2
⊢ (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
h : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
tactic: have : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K := by simpa using hcycl
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
h : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ (Algebra.norm ℤ) (hζ.toInteger - 1) = ↑↑p
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ✝ : IsPrimitiveRoot ζ ↑p
h : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
hζ : IsPrimitiveRoot ζ (↑p ^ (0 + 1))
⊢ (Algebra.norm ℤ) (hζ✝.toInteger - 1) = ↑↑p
tactic: replace hζ : IsPrimitiveRoot ζ (p ^ (0 + 1)) := by simpa using hζ
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ✝ : IsPrimitiveRoot ζ ↑p
h : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
hζ : IsPrimitiveRoot ζ (↑p ^ (0 + 1))
⊢ (Algebra.norm ℤ) (hζ✝.toInteger - 1) = ↑↑p
state_after: no goals
tactic: exact hζ.norm_toInteger_sub_one_of_prime_ne_two h
Theorem: Homeomorph.compStarAlgEquiv'_symm_apply
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁸ : TopologicalSpace X
inst✝⁷ : TopologicalSpace Y
𝕜 : Type u_3
inst✝⁶ : CommSemiring 𝕜
A : Type u_4
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Semiring A
inst✝³ : TopologicalSemiring A
inst✝² : StarRing A
inst✝¹ : ContinuousStar A
inst✝ : Algebra 𝕜 A
f : X ≃ₜ Y
g : C(Y, A)
⊢ (ContinuousMap.compStarAlgHom' 𝕜 A f.symm.toContinuousMap) ((ContinuousMap.compStarAlgHom' 𝕜 A f.toContinuousMap) g) =
    g
state_after: no goals
tactic: simp only [ContinuousMap.compStarAlgHom'_apply, ContinuousMap.comp_assoc,
        toContinuousMap_comp_symm, ContinuousMap.comp_id]
state_before: X : Type u_1
Y : Type u_2
inst✝⁸ : TopologicalSpace X
inst✝⁷ : TopologicalSpace Y
𝕜 : Type u_3
inst✝⁶ : CommSemiring 𝕜
A : Type u_4
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Semiring A
inst✝³ : TopologicalSemiring A
inst✝² : StarRing A
inst✝¹ : ContinuousStar A
inst✝ : Algebra 𝕜 A
f : X ≃ₜ Y
g : C(X, A)
⊢ (ContinuousMap.compStarAlgHom' 𝕜 A f.toContinuousMap) ((ContinuousMap.compStarAlgHom' 𝕜 A f.symm.toContinuousMap) g) =
    g
state_after: no goals
tactic: simp only [ContinuousMap.compStarAlgHom'_apply, ContinuousMap.comp_assoc,
        symm_comp_toContinuousMap, ContinuousMap.comp_id]
Theorem: Submodule.map_subtype_range_inclusion
File: Mathlib/Algebra/Module/Submodule/Range.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝⁷ : Semiring R
inst✝⁶ : Semiring R₂
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R₂ M₂
p✝ p'✝ : Submodule R M
q : Submodule R₂ M₂
τ₁₂ : R →+* R₂
F : Type u_11
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
p p' : Submodule R M
h : p ≤ p'
⊢ map p'.subtype (range (inclusion h)) = p
state_after: no goals
tactic: simp [range_inclusion, map_comap_eq, h]
Theorem: AlgebraicTopology.NormalizedMooreComplex.map_f
File: Mathlib/AlgebraicTopology/MooreComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.34821, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n : ℕ
⊢ (objX Y n).Factors ((objX X n).arrow ≫ f.app (op (SimplexCategory.mk n)))
state_after: case zero
C : Type u_1
inst✝¹ : Category.{?u.34821, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
⊢ ⊤.Factors (⊤.arrow ≫ f.app (op (SimplexCategory.mk 0)))

case succ
C : Type u_1
inst✝¹ : Category.{?u.34821, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n✝ : ℕ
⊢ (Finset.univ.inf fun k => kernelSubobject (Y.δ k.succ)).Factors
    ((Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ f.app (op (SimplexCategory.mk (n✝ + 1))))
tactic: cases n <;> dsimp
state_before: C : Type u_1
inst✝¹ : Category.{?u.34821, u_1} C
inst✝ : Abelian C
X Y : SimplicialObject C
f✝ f : X ⟶ Y
n : ℕ
⊢ (fun n => (objX Y n).factorThru ((objX X n).arrow ≫ f.app (op (SimplexCategory.mk n))) ⋯) (n + 1) ≫ objD Y n =
    objD X n ≫ (fun n => (objX Y n).factorThru ((objX X n).arrow ≫ f.app (op (SimplexCategory.mk n))) ⋯) n
state_after: no goals
tactic: cases n <;> dsimp [objD, objX] <;> aesop_cat
Theorem: MeasureTheory.withDensity_smul
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
⊢ μ.withDensity (r • f) = r • μ.withDensity f
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (r • f)) s = (r • μ.withDensity f) s
tactic: refine Measure.ext fun s hs => ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (r • f)) s = (r • μ.withDensity f) s
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, (r • f) a ∂μ = ∫⁻ (a : α) in s, r * f a ∂μ
tactic: rw [withDensity_apply _ hs, Measure.coe_smul, Pi.smul_apply, withDensity_apply _ hs,
    smul_eq_mul, ← lintegral_const_mul r hf]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, (r • f) a ∂μ = ∫⁻ (a : α) in s, r * f a ∂μ
state_after: no goals
tactic: simp only [Pi.smul_apply, smul_eq_mul]
Theorem: Multiset.countP_attach
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) (attach ⟦l⟧) = countP p ⟦l⟧
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) (↑l).attach = List.countP (fun b => decide (p b)) l
tactic: simp only [quot_mk_to_coe, coe_countP]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) (↑l).attach = List.countP (fun b => decide (p b)) l
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) ↑l.attach = List.countP (fun b => decide (p b)) l
tactic: rw [coe_attach]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ countP (fun a => p ↑a) ↑l.attach = List.countP (fun b => decide (p b)) l
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun b => decide (p b)) l
tactic: refine (coe_countP _ _).trans ?_
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun b => decide (p b)) l
state_after: case h.e'_2
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun a => decide (p ↑a)) l.attach
tactic: convert List.countP_attach _ _
state_before: case h.e'_2
α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
l : List α
⊢ List.countP (fun b => decide (p ↑b)) l.attach = List.countP (fun a => decide (p ↑a)) l.attach
state_after: no goals
tactic: rfl
Theorem: Nat.four_pow_le_two_mul_add_one_mul_central_binom
File: Mathlib/Data/Nat/Choose/Sum.lean

Proof steps:
state_before: R : Type u_1
n : ℕ
⊢ 4 ^ n = (1 + 1) ^ (2 * n)
state_after: no goals
tactic: norm_num [pow_mul]
state_before: R : Type u_1
n : ℕ
⊢ (1 + 1) ^ (2 * n) = ∑ m ∈ range (2 * n + 1), (2 * n).choose m
state_after: no goals
tactic: set_option simprocs false in simp [add_pow]
state_before: R : Type u_1
n : ℕ
⊢ ∑ m ∈ range (2 * n + 1), (2 * n).choose m ≤ ∑ m ∈ range (2 * n + 1), (2 * n).choose (2 * n / 2)
state_after: case h
R : Type u_1
n i✝ : ℕ
a✝ : i✝ ∈ range (2 * n + 1)
⊢ (2 * n).choose i✝ ≤ (2 * n).choose (2 * n / 2)
tactic: gcongr
state_before: case h
R : Type u_1
n i✝ : ℕ
a✝ : i✝ ∈ range (2 * n + 1)
⊢ (2 * n).choose i✝ ≤ (2 * n).choose (2 * n / 2)
state_after: no goals
tactic: apply choose_le_middle
state_before: R : Type u_1
n : ℕ
⊢ ∑ m ∈ range (2 * n + 1), (2 * n).choose (2 * n / 2) = (2 * n + 1) * (2 * n).choose n
state_after: no goals
tactic: simp
Theorem: RelEmbedding.eq_preimage
File: Mathlib/Order/RelIso/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
⊢ r = ⇑f ⁻¹'o s
state_after: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a b : α
⊢ r a b ↔ (⇑f ⁻¹'o s) a b
tactic: ext a b
state_before: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a b : α
⊢ r a b ↔ (⇑f ⁻¹'o s) a b
state_after: no goals
tactic: exact f.map_rel_iff.symm
Theorem: Option.map₂_left_identity
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
o : Option β
⊢ map₂ f (some a) o = o
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
⊢ map₂ f (some a) none = none

case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
val✝ : β
⊢ map₂ f (some a) (some val✝) = some val✝
tactic: cases o
state_before: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
⊢ map₂ f (some a) none = none

case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f✝ : α → β → γ
a✝ : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
f : α → β → β
a : α
h : ∀ (b : β), f a b = b
val✝ : β
⊢ map₂ f (some a) (some val✝) = some val✝
state_after: no goals
tactic: exacts [rfl, congr_arg some (h _)]
Theorem: Submodule.LinearDisjoint.of_subsingleton
File: Mathlib/LinearAlgebra/LinearDisjoint.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommSemiring R
inst✝² : Semiring S
inst✝¹ : Algebra R S
M N : Submodule R S
inst✝ : Subsingleton R
⊢ M.LinearDisjoint N
state_after: R : Type u
S : Type v
inst✝³ : CommSemiring R
inst✝² : Semiring S
inst✝¹ : Algebra R S
M N : Submodule R S
inst✝ : Subsingleton R
this : Subsingleton S
⊢ M.LinearDisjoint N
tactic: haveI : Subsingleton S := Module.subsingleton R S
state_before: R : Type u
S : Type v
inst✝³ : CommSemiring R
inst✝² : Semiring S
inst✝¹ : Algebra R S
M N : Submodule R S
inst✝ : Subsingleton R
this : Subsingleton S
⊢ M.LinearDisjoint N
state_after: no goals
tactic: exact ⟨Function.injective_of_subsingleton _⟩
Theorem: IsAddUnit.liftRight_neg_add
File: Mathlib/Algebra/Group/Units/Hom.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x : M
⊢ ∀ (x : M), ↑⋯.unit = f x
state_after: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
tactic: intro
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
state_after: no goals
tactic: rfl
Theorem: norm_sub_sq
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 y : E
⊢ ‖x - y‖ ^ 2 = ‖x‖ ^ 2 - 2 * re ⟪x, y⟫_𝕜 + ‖y‖ ^ 2
state_after: no goals
tactic: rw [sub_eq_add_neg, @norm_add_sq 𝕜 _ _ _ _ x (-y), norm_neg, inner_neg_right, map_neg, mul_neg,
    sub_eq_add_neg]
Theorem: CategoryTheory.GrothendieckTopology.arrow_stable
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S✝ R : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S : Sieve X
h : J.Covers S f
Z : C
g : Z ⟶ Y
⊢ J.Covers S (g ≫ f)
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S✝ R : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S : Sieve X
h : Sieve.pullback f S ∈ J.sieves Y
Z : C
g : Z ⟶ Y
⊢ Sieve.pullback (g ≫ f) S ∈ J.sieves Z
tactic: rw [covers_iff] at h ⊢
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S✝ R : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S : Sieve X
h : Sieve.pullback f S ∈ J.sieves Y
Z : C
g : Z ⟶ Y
⊢ Sieve.pullback (g ≫ f) S ∈ J.sieves Z
state_after: no goals
tactic: simp [h, Sieve.pullback_comp]
Theorem: CategoryTheory.ShortComplex.Exact.op
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.17758, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.Exact
⊢ S.op.Exact
state_after: case mk.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.17758, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.HomologyData
z : IsZero h.left.H
⊢ S.op.Exact
tactic: obtain ⟨h, z⟩ := h
state_before: case mk.intro
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.17758, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.HomologyData
z : IsZero h.left.H
⊢ S.op.Exact
state_after: no goals
tactic: exact ⟨⟨h.op, (IsZero.of_iso z h.iso.symm).op⟩⟩
Theorem: eq_orthogonalProjection_of_mem_orthogonal'
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
u v z : E
hv : v ∈ K
hz : z ∈ Kᗮ
hu : u = v + z
⊢ u - v ∈ Kᗮ
state_after: no goals
tactic: simpa [hu]
Theorem: Mathlib.Tactic.Abel.term_atom_pfg
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
x x' : α
h : x = x'
⊢ x = termg 1 x' 0
state_after: no goals
tactic: simp [termg, h]
Theorem: Polynomial.natDegree_linear
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
ha : a ≠ 0
⊢ (C a * X + C b).natDegree = 1
state_after: no goals
tactic: rw [natDegree_add_C, natDegree_C_mul_X a ha]
Theorem: Int.even_pow
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v m n✝ : ℤ
n : ℕ
⊢ Even (m ^ n) ↔ Even m ∧ n ≠ 0
state_after: case succ
u v m n✝ : ℤ
n : ℕ
ih : Even (m ^ n) ↔ Even m ∧ n ≠ 0
⊢ Even m → ¬n = 0 → Even m
tactic: induction' n with n ih <;> simp [*, even_mul, pow_succ]
state_before: case succ
u v m n✝ : ℤ
n : ℕ
ih : Even (m ^ n) ↔ Even m ∧ n ≠ 0
⊢ Even m → ¬n = 0 → Even m
state_after: no goals
tactic: tauto
Theorem: Equiv.Set.sumCompl_symm_apply_of_mem
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
⊢ (Set.sumCompl s).symm x = Sum.inl ⟨x, hx⟩
state_after: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Set.sumCompl s).symm x = Sum.inl ⟨x, hx⟩
tactic: have : ((⟨x, Or.inl hx⟩ : (s ∪ sᶜ : Set α)) : α) ∈ s := hx
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Set.sumCompl s).symm x = Sum.inl ⟨x, hx⟩
state_after: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Trans.trans (Trans.trans (Set.union ⋯).symm (Set.ofEq ⋯)) (Set.univ α)).symm x = Sum.inl ⟨x, hx⟩
tactic: rw [Equiv.Set.sumCompl]
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type u
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
x : α
hx : x ∈ s
this : ↑⟨x, ⋯⟩ ∈ s
⊢ (Trans.trans (Trans.trans (Set.union ⋯).symm (Set.ofEq ⋯)) (Set.univ α)).symm x = Sum.inl ⟨x, hx⟩
state_after: no goals
tactic: simpa using Set.union_apply_left (by simp) this
Theorem: cauchySeq_of_edist_le_geometric_two
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C / 2 ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
⊢ CauchySeq f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ CauchySeq f
tactic: simp only [div_eq_mul_inv, ENNReal.inv_pow] at hu
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ CauchySeq f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ 2⁻¹ < 1
tactic: refine cauchySeq_of_edist_le_geometric 2⁻¹ C ?_ hC hu
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ 2⁻¹ < 1
state_after: no goals
tactic: simp [ENNReal.one_lt_two]
Theorem: toIcoDiv_apply_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a + p - 1 • p ∈ Set.Ico a (a + p)
state_after: no goals
tactic: simp [hp]
Theorem: CategoryTheory.SimplicialObject.augment_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ ∀ ⦃X_1 Y : SimplexCategoryᵒᵖ⦄ (f_1 : X_1 ⟶ Y),
    ((𝟭 (SimplicialObject C)).obj X).map f_1 ≫ (fun i => X.map ([0].const (unop i) 0).op ≫ f) Y =
      (fun i => X.map ([0].const (unop i) 0).op ≫ f) X_1 ≫ ((const C).obj X₀).map f_1
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ ((𝟭 (SimplicialObject C)).obj X).map g ≫ (fun i => X.map ([0].const (unop i) 0).op ≫ f) j =
    (fun i => X.map ([0].const (unop i) 0).op ≫ f) i ≫ ((const C).obj X₀).map g
tactic: intro i j g
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ ((𝟭 (SimplicialObject C)).obj X).map g ≫ (fun i => X.map ([0].const (unop i) 0).op ≫ f) j =
    (fun i => X.map ([0].const (unop i) 0).op ≫ f) i ≫ ((const C).obj X₀).map g
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g.unop.op ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
tactic: rw [← g.op_unop]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X _[0] ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g.unop.op ≫ X.map ([0].const (unop j) 0).op ≫ f = (X.map ([0].const (unop i) 0).op ≫ f) ≫ 𝟙 X₀
state_after: no goals
tactic: simpa only [← X.map_comp, ← Category.assoc, Category.comp_id, ← op_comp] using w _ _ _