ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.coprod.leftUnitor_hom
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y : C
inst✝² : Category.{v, u} C
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
P : C
⊢ desc (initial.to P) (𝟙 P) ≫ inr = 𝟙 ((⊥_ C) ⨿ P)
state_after: no goals
tactic: apply coprod.hom_ext <;> simp [eq_iff_true_of_subsingleton]
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y : C
inst✝² : Category.{v, u} C
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasInitial C
P : C
⊢ inr ≫ desc (initial.to P) (𝟙 P) = 𝟙 P
state_after: no goals
tactic: simp
Theorem: ModuleCat.MonoidalCategory.braiding_naturality_right
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Symmetric.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
f : Y ⟶ Z
⊢ X ◁ f ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X
state_after: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
f : Y ⟶ Z
⊢ (𝟙 X ⊗ f) ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X
tactic: simp_rw [← id_tensorHom]
state_before: R : Type u
inst✝ : CommRing R
X Y Z : ModuleCat R
f : Y ⟶ Z
⊢ (𝟙 X ⊗ f) ≫ (X.braiding Z).hom = (X.braiding Y).hom ≫ f ▷ X
state_after: no goals
tactic: apply braiding_naturality
Theorem: CategoryTheory.Limits.Concrete.isColimit_exists_of_rep_eq
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
J : Type w
inst✝² : Category.{r, w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F (forget C)
inst✝ : IsFiltered J
D : Cocone F
i j : J
hD : IsColimit D
x : (forget C).obj (F.obj i)
y : (forget C).obj (F.obj j)
h : (D.ι.app i) x = (D.ι.app j) y
⊢ ∃ k f g, (F.map f) x = (F.map g) y
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
J : Type w
inst✝² : Category.{r, w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F (forget C)
inst✝ : IsFiltered J
D : Cocone F
i j : J
hD : IsColimit D
x : (forget C).obj (F.obj i)
y : (forget C).obj (F.obj j)
h : (D.ι.app i) x = (D.ι.app j) y
E : Cocone (F ⋙ forget C) := (forget C).mapCocone D
⊢ ∃ k f g, (F.map f) x = (F.map g) y
tactic: let E := (forget C).mapCocone D
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
J : Type w
inst✝² : Category.{r, w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F (forget C)
inst✝ : IsFiltered J
D : Cocone F
i j : J
hD : IsColimit D
x : (forget C).obj (F.obj i)
y : (forget C).obj (F.obj j)
h : (D.ι.app i) x = (D.ι.app j) y
E : Cocone (F ⋙ forget C) := (forget C).mapCocone D
⊢ ∃ k f g, (F.map f) x = (F.map g) y
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
J : Type w
inst✝² : Category.{r, w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F (forget C)
inst✝ : IsFiltered J
D : Cocone F
i j : J
hD : IsColimit D
x : (forget C).obj (F.obj i)
y : (forget C).obj (F.obj j)
h : (D.ι.app i) x = (D.ι.app j) y
E : Cocone (F ⋙ forget C) := (forget C).mapCocone D
hE : IsColimit E := isColimitOfPreserves (forget C) hD
⊢ ∃ k f g, (F.map f) x = (F.map g) y
tactic: let hE : IsColimit E := isColimitOfPreserves _ hD
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
J : Type w
inst✝² : Category.{r, w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F (forget C)
inst✝ : IsFiltered J
D : Cocone F
i j : J
hD : IsColimit D
x : (forget C).obj (F.obj i)
y : (forget C).obj (F.obj j)
h : (D.ι.app i) x = (D.ι.app j) y
E : Cocone (F ⋙ forget C) := (forget C).mapCocone D
hE : IsColimit E := isColimitOfPreserves (forget C) hD
⊢ ∃ k f g, (F.map f) x = (F.map g) y
state_after: no goals
tactic: exact (Types.FilteredColimit.isColimit_eq_iff (F ⋙ forget C) hE).mp h
Theorem: ContDiff.dimH_range_le
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
E : Type u_4
F : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
h : ContDiff ℝ 1 f
⊢ dimH (range f) = dimH (f '' univ)
state_after: no goals
tactic: rw [image_univ]
Theorem: LipschitzOnWith.norm_sub_le_of_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : E → F
C : ℝ≥0
h : LipschitzOnWith C f s
ha : a ∈ s
hb : b ∈ s
hr : ‖a / b‖ ≤ r
⊢ ↑C * ‖a / b‖ ≤ ↑C * r
state_after: no goals
tactic: gcongr
Theorem: padicValNat.zero
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
⊢ padicValNat p 0 = 0
state_after: no goals
tactic: simp [padicValNat]
Theorem: FormalMultilinearSeries.le_radius_of_eventually_le
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
C : ℝ
h : ∀ᶠ (n : ℕ) in atTop, ‖p n‖ * ↑r ^ n ≤ C
n : ℕ
hn : ‖p n‖ * ↑r ^ n ≤ C
⊢ ‖‖p n‖ * ↑r ^ n‖ ≤ C * ‖1‖
state_after: no goals
tactic: simpa
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.add
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
h1 : μ₁ ≪ ν
h2 : μ₂ ≪ ν'
⊢ μ₁ + μ₂ ≪ ν + ν'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
h1 : μ₁ ≪ ν
h2 : μ₂ ≪ ν'
s : Set α
hs : (ν + ν') s = 0
⊢ (μ₁ + μ₂) s = 0
tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
h1 : μ₁ ≪ ν
h2 : μ₂ ≪ ν'
s : Set α
hs : (ν + ν') s = 0
⊢ (μ₁ + μ₂) s = 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
h1 : μ₁ ≪ ν
h2 : μ₂ ≪ ν'
s : Set α
hs : ν s = 0 ∧ ν' s = 0
⊢ μ₁ s = 0 ∧ μ₂ s = 0
tactic: simp only [coe_add, Pi.add_apply, add_eq_zero] at hs ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
h1 : μ₁ ≪ ν
h2 : μ₂ ≪ ν'
s : Set α
hs : ν s = 0 ∧ ν' s = 0
⊢ μ₁ s = 0 ∧ μ₂ s = 0
state_after: no goals
tactic: exact ⟨h1 hs.1, h2 hs.2⟩
Theorem: Equiv.tprod_eq_tprod_of_mulSupport
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
f : β → α
g : γ → α
e : ↑(mulSupport f) ≃ ↑(mulSupport g)
he : ∀ (x : ↑(mulSupport f)), g ↑(e x) = f ↑x
⊢ mulSupport g ⊆ Set.range (Subtype.val ∘ ⇑e)
state_after: no goals
tactic: simp
Theorem: contDiff_succ_iff_fderiv
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ContDiff 𝕜 ↑n fun y => fderiv 𝕜 f y
state_after: no goals
tactic: simp only [← contDiffOn_univ, ← differentiableOn_univ, ← fderivWithin_univ,
    contDiffOn_succ_iff_fderivWithin uniqueDiffOn_univ]
Theorem: Polynomial.dickson_two
File: Mathlib/RingTheory/Polynomial/Dickson.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
⊢ dickson k a 2 = X ^ 2 - C a * (3 - ↑k)
state_after: no goals
tactic: simp only [dickson, sq]
Theorem: List.foldlIdx_eq_foldlIdxSpec
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
f : ℕ → α → β → α
a : α
bs : List β
start : ℕ
⊢ foldlIdx f a bs start = foldlIdxSpec f a bs start
state_after: case nil
α : Type u
β : Type v
f : ℕ → α → β → α
a : α
start : ℕ
⊢ foldlIdx f a [] start = foldlIdxSpec f a [] start

case cons
α : Type u
β : Type v
f : ℕ → α → β → α
head✝ : β
tail✝ : List β
tail_ih✝ : ∀ (a : α) (start : ℕ), foldlIdx f a tail✝ start = foldlIdxSpec f a tail✝ start
a : α
start : ℕ
⊢ foldlIdx f a (head✝ :: tail✝) start = foldlIdxSpec f a (head✝ :: tail✝) start
tactic: induction bs generalizing start a
Theorem: Nat.doubleFactorial_le_factorial
File: Mathlib/Data/Nat/Factorial/DoubleFactorial.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 1)‼ ≤ (n + 1)!
state_after: n : ℕ
⊢ (n + 1)‼ ≤ (n + 1)‼ * n‼
tactic: rw [factorial_eq_mul_doubleFactorial]
state_before: n : ℕ
⊢ (n + 1)‼ ≤ (n + 1)‼ * n‼
state_after: no goals
tactic: exact Nat.le_mul_of_pos_right _ n.doubleFactorial_pos
Theorem: Int.dvd_of_mul_dvd_mul_left
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
ha : a ≠ 0
h : a * m ∣ a * n
⊢ m ∣ n
state_after: case intro
a b✝ c d m n : ℤ
ha : a ≠ 0
b : ℤ
hb : a * n = a * m * b
⊢ m ∣ n
tactic: obtain ⟨b, hb⟩ := h
state_before: case intro
a b✝ c d m n : ℤ
ha : a ≠ 0
b : ℤ
hb : a * n = a * m * b
⊢ m ∣ n
state_after: case intro
a b✝ c d m n : ℤ
ha : a ≠ 0
b : ℤ
hb : n = m * b
⊢ m ∣ n
tactic: rw [Int.mul_assoc, Int.mul_eq_mul_left_iff ha] at hb
state_before: case intro
a b✝ c d m n : ℤ
ha : a ≠ 0
b : ℤ
hb : n = m * b
⊢ m ∣ n
state_after: no goals
tactic: exact ⟨_, hb⟩
Theorem: Filter.eventually_or_distrib_left
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
state_after: no goals
tactic: simp [h]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
h : ¬p
⊢ (∀ᶠ (x : α) in f, p ∨ q x) ↔ p ∨ ∀ᶠ (x : α) in f, q x
state_after: no goals
tactic: simp [h]
Theorem: MvPowerSeries.smul_eq_C_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
f : MvPowerSeries σ R
a : R
⊢ a • f = (C σ R) a * f
state_after: case h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
f : MvPowerSeries σ R
a : R
n✝ : σ →₀ ℕ
⊢ (coeff R n✝) (a • f) = (coeff R n✝) ((C σ R) a * f)
tactic: ext
state_before: case h
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
f : MvPowerSeries σ R
a : R
n✝ : σ →₀ ℕ
⊢ (coeff R n✝) (a • f) = (coeff R n✝) ((C σ R) a * f)
state_after: no goals
tactic: simp
Theorem: Basis.reindexFinsetRange_self
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
h : optParam (b i ∈ Finset.image (⇑b) Finset.univ) ⋯
⊢ b.reindexFinsetRange ⟨b i, h⟩ = b i
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
h : optParam (b i ∈ Finset.image (⇑b) Finset.univ) ⋯
⊢ ↑(((Equiv.refl M).subtypeEquiv ⋯).symm ⟨b i, h⟩) = b i
tactic: rw [reindexFinsetRange, reindex_apply, reindexRange_apply]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
h : optParam (b i ∈ Finset.image (⇑b) Finset.univ) ⋯
⊢ ↑(((Equiv.refl M).subtypeEquiv ⋯).symm ⟨b i, h⟩) = b i
state_after: no goals
tactic: rfl
Theorem: LieSubalgebra.isNilpotent_ad_of_isNilpotent_ad
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
h : IsNilpotent ((LieAlgebra.ad R L) ↑x)
⊢ IsNilpotent ((LieAlgebra.ad R ↥K) x)
state_after: case intro
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ IsNilpotent ((LieAlgebra.ad R ↥K) x)
tactic: obtain ⟨n, hn⟩ := h
state_before: case intro
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ IsNilpotent ((LieAlgebra.ad R ↥K) x)
state_after: case h
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ (LieAlgebra.ad R ↥K) x ^ n = 0
tactic: use n
state_before: case h
R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Algebra R A
L : Type v
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
K : LieSubalgebra R L
x : ↥K
n : ℕ
hn : (LieAlgebra.ad R L) ↑x ^ n = 0
⊢ (LieAlgebra.ad R ↥K) x ^ n = 0
state_after: no goals
tactic: exact LinearMap.submodule_pow_eq_zero_of_pow_eq_zero (K.ad_comp_incl_eq x) hn
Theorem: CommRingCat.KaehlerDifferential.ext
File: Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean

Proof steps:
state_before: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
⊢ α = β
state_after: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
⊢ α - β = 0
tactic: rw [← sub_eq_zero]
state_before: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
⊢ α - β = 0
state_after: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
this : ⊤ ≤ LinearMap.ker (α - β)
⊢ α - β = 0
tactic: have : ⊤ ≤ LinearMap.ker (α - β) := by
    rw [← KaehlerDifferential.span_range_derivation, Submodule.span_le]
    rintro _ ⟨y, rfl⟩
    rw [SetLike.mem_coe, LinearMap.mem_ker, LinearMap.sub_apply, sub_eq_zero]
    apply h
state_before: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
this : ⊤ ≤ LinearMap.ker (α - β)
⊢ α - β = 0
state_after: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
this : α - β = 0
⊢ α - β = 0
tactic: rw [top_le_iff, LinearMap.ker_eq_top] at this
state_before: A B A' B' : CommRingCat
f : A ⟶ B
f' : A' ⟶ B'
g : A ⟶ A'
g' : B ⟶ B'
fac : g ≫ f' = f ≫ g'
M : ModuleCat ↑B
α β : KaehlerDifferential f ⟶ M
h : ∀ (b : ↑B), α (d b) = β (d b)
this : α - β = 0
⊢ α - β = 0
state_after: no goals
tactic: exact this
Theorem: IsCompact.neg
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : InvolutiveInv G
inst✝ : ContinuousInv G
s : Set G
hs : IsCompact s
⊢ IsCompact s⁻¹
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : InvolutiveInv G
inst✝ : ContinuousInv G
s : Set G
hs : IsCompact s
⊢ IsCompact (Inv.inv '' s)
tactic: rw [← image_inv]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : InvolutiveInv G
inst✝ : ContinuousInv G
s : Set G
hs : IsCompact s
⊢ IsCompact (Inv.inv '' s)
state_after: no goals
tactic: exact hs.image continuous_inv
Theorem: specializingMap_iff_stableUnderSpecialization_image_singleton
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f g : X → Y
⊢ SpecializingMap f ↔ ∀ (x : X), StableUnderSpecialization (f '' closure {x})
state_after: no goals
tactic: simpa only [closure_singleton_eq_Iic] using Relation.fibration_iff_isLowerSet_image_Iic
Theorem: MeasureTheory.Measure.zero_conv
File: Mathlib/MeasureTheory/Group/Convolution.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : Monoid M
inst✝ : MeasurableSpace M
μ : Measure M
⊢ μ ∗ 0 = 0
state_after: M : Type u_1
inst✝¹ : Monoid M
inst✝ : MeasurableSpace M
μ : Measure M
⊢ map (fun x => x.1 * x.2) (μ.prod 0) = 0
tactic: unfold mconv
state_before: M : Type u_1
inst✝¹ : Monoid M
inst✝ : MeasurableSpace M
μ : Measure M
⊢ map (fun x => x.1 * x.2) (μ.prod 0) = 0
state_after: no goals
tactic: simp
Theorem: Complex.interior_reProdIm
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: s t : Set ℝ
⊢ interior (s ×ℂ t) = interior s ×ℂ interior t
state_after: no goals
tactic: rw [Set.reProdIm, Set.reProdIm, interior_inter, interior_preimage_re, interior_preimage_im]
Theorem: Left.pow_le_one_of_le
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
hx : x ≤ 1
n : ℕ
⊢ x ^ (n + 1) ≤ 1
state_after: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
hx : x ≤ 1
n : ℕ
⊢ x ^ n * x ≤ 1
tactic: rw [pow_succ]
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
hx : x ≤ 1
n : ℕ
⊢ x ^ n * x ≤ 1
state_after: no goals
tactic: exact Left.mul_le_one (Left.pow_le_one_of_le hx) hx
Theorem: ChainComplex.truncate_map_f
File: Mathlib/Algebra/Homology/Augment.lean

Proof steps:
state_before: V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i j : ℕ
w : ¬(ComplexShape.down ℕ).Rel i j
⊢ ¬(ComplexShape.down ℕ).Rel (i + 1) (j + 1)
state_after: no goals
tactic: simpa
Theorem: List.countP_false
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP (fun x => false) l = 0
state_after: α : Type u_1
p q : α → Bool
l : List α
⊢ ∀ (a : α), a ∈ l → ¬false = true
tactic: rw [countP_eq_zero]
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ ∀ (a : α), a ∈ l → ¬false = true
state_after: no goals
tactic: simp
Theorem: Nat.card_Iic
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
⊢ (Iic b).card = b + 1
state_after: no goals
tactic: rw [Iic_eq_Icc, card_Icc, Nat.bot_eq_zero, Nat.sub_zero]
Theorem: FirstOrder.Language.realize_noTopOrder_iff
File: Mathlib/ModelTheory/Order.lean

Proof steps:
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ M ⊨ Language.order.noTopOrderSentence ↔ NoTopOrder M
state_after: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ (∀ (a : M), ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 1 ≤ Fin.snoc (Fin.snoc default a) a_1 0) ↔ NoTopOrder M
tactic: simp only [noTopOrderSentence, Sentence.Realize, Formula.Realize, BoundedFormula.realize_all,
    BoundedFormula.realize_ex, BoundedFormula.realize_not, Term.realize, Term.realize_le,
    Sum.elim_inr]
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ (∀ (a : M), ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 1 ≤ Fin.snoc (Fin.snoc default a) a_1 0) ↔ NoTopOrder M
state_after: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ NoTopOrder M → ∀ (a : M), ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 1 ≤ Fin.snoc (Fin.snoc default a) a_1 0
tactic: refine ⟨fun h => ⟨fun a => h a⟩, ?_⟩
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
⊢ NoTopOrder M → ∀ (a : M), ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 1 ≤ Fin.snoc (Fin.snoc default a) a_1 0
state_after: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
h : NoTopOrder M
a : M
⊢ ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 1 ≤ Fin.snoc (Fin.snoc default a) a_1 0
tactic: intro h a
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝ : LE M
h : NoTopOrder M
a : M
⊢ ∃ a_1, ¬Fin.snoc (Fin.snoc default a) a_1 1 ≤ Fin.snoc (Fin.snoc default a) a_1 0
state_after: no goals
tactic: exact exists_not_le a
Theorem: MeasurableSpace.measurable_injection_nat_bool_of_countablySeparated
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
⊢ ∃ f, Measurable f ∧ Injective f
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝¹ : CountablyGenerated α
left✝ : SeparatesPoints α
m'le : m' ≤ inst✝¹
⊢ ∃ f, Measurable f ∧ Injective f
tactic: rcases exists_countablyGenerated_le_of_countablySeparated α with ⟨m', _, _, m'le⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝¹ : CountablyGenerated α
left✝ : SeparatesPoints α
m'le : m' ≤ inst✝¹
⊢ ∃ f, Measurable f ∧ Injective f
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝¹ : CountablyGenerated α
left✝ : SeparatesPoints α
m'le : m' ≤ inst✝¹
⊢ Measurable (mapNatBool α)
tactic: refine ⟨mapNatBool α, ?_, injective_mapNatBool _⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
m' : MeasurableSpace α
left✝¹ : CountablyGenerated α
left✝ : SeparatesPoints α
m'le : m' ≤ inst✝¹
⊢ Measurable (mapNatBool α)
state_after: no goals
tactic: exact (measurable_mapNatBool _).mono m'le le_rfl
Theorem: Complex.abs_eq_one_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z✝ z : ℂ
⊢ abs z = 1 ↔ ∃ θ, cexp (↑θ * I) = z
state_after: case refine_1
a x z✝ z : ℂ
hz : abs z = 1
⊢ cexp (↑z.arg * I) = z

case refine_2
a x z✝ z : ℂ
⊢ (∃ θ, cexp (↑θ * I) = z) → abs z = 1
tactic: refine ⟨fun hz => ⟨arg z, ?_⟩, ?_⟩