ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.IsStoppingTime.measurableSet_ge
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝³ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
inst✝² : TopologicalSpace ι
inst✝¹ : OrderTopology ι
inst✝ : FirstCountableTopology ι
hτ : IsStoppingTime f τ
i : ι
⊢ MeasurableSet {ω | i ≤ τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝³ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
inst✝² : TopologicalSpace ι
inst✝¹ : OrderTopology ι
inst✝ : FirstCountableTopology ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | i ≤ τ ω}
tactic: have : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ := by
    ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_compl_iff, not_lt]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝³ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
inst✝² : TopologicalSpace ι
inst✝¹ : OrderTopology ι
inst✝ : FirstCountableTopology ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | i ≤ τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝³ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
inst✝² : TopologicalSpace ι
inst✝¹ : OrderTopology ι
inst✝ : FirstCountableTopology ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | τ ω < i}ᶜ
tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝³ : LinearOrder ι
f : Filtration ι m
τ : Ω → ι
inst✝² : TopologicalSpace ι
inst✝¹ : OrderTopology ι
inst✝ : FirstCountableTopology ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | τ ω < i}ᶜ
state_after: no goals
tactic: exact (hτ.measurableSet_lt i).compl
Theorem: MeasureTheory.condexpL1CLM_smul
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹¹ : RCLike 𝕜
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
inst✝⁸ : NormedAddCommGroup F'
inst✝⁷ : NormedSpace 𝕜 F'
inst✝⁶ : NormedSpace ℝ F'
inst✝⁵ : CompleteSpace F'
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedAddCommGroup G'
inst✝² : NormedSpace ℝ G'
inst✝¹ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
f✝ g : α → F'
s : Set α
c : 𝕜
f : ↥(Lp F' 1 μ)
⊢ (condexpL1CLM F' hm μ) (c • f) = c • (condexpL1CLM F' hm μ) f
state_after: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹¹ : RCLike 𝕜
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
inst✝⁸ : NormedAddCommGroup F'
inst✝⁷ : NormedSpace 𝕜 F'
inst✝⁶ : NormedSpace ℝ F'
inst✝⁵ : CompleteSpace F'
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedAddCommGroup G'
inst✝² : NormedSpace ℝ G'
inst✝¹ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
f✝ g : α → F'
s : Set α
c : 𝕜
f : ↥(Lp F' 1 μ)
⊢ ∀ (c : 𝕜) (s : Set α) (x : F'), (condexpInd F' hm μ s) (c • x) = c • (condexpInd F' hm μ s) x
tactic: refine L1.setToL1_smul (dominatedFinMeasAdditive_condexpInd F' hm μ) ?_ c f
state_before: α : Type u_1
β : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹¹ : RCLike 𝕜
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
inst✝⁸ : NormedAddCommGroup F'
inst✝⁷ : NormedSpace 𝕜 F'
inst✝⁶ : NormedSpace ℝ F'
inst✝⁵ : CompleteSpace F'
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedAddCommGroup G'
inst✝² : NormedSpace ℝ G'
inst✝¹ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
f✝ g : α → F'
s : Set α
c : 𝕜
f : ↥(Lp F' 1 μ)
⊢ ∀ (c : 𝕜) (s : Set α) (x : F'), (condexpInd F' hm μ s) (c • x) = c • (condexpInd F' hm μ s) x
state_after: no goals
tactic: exact fun c s x => condexpInd_smul' c x
Theorem: Cardinal.lift_iInf
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ lift.{u, v} (iInf f) = ⨅ i, lift.{u, v} (f i)
state_after: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ lift.{u, v} (sInf (range f)) = sInf (range fun i => lift.{u, v} (f i))
tactic: unfold iInf
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ lift.{u, v} (sInf (range f)) = sInf (range fun i => lift.{u, v} (f i))
state_after: case h.e'_3.h.e'_3
α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ (range fun i => lift.{u, v} (f i)) = lift.{u, v} '' range f
tactic: convert lift_sInf (range f)
state_before: case h.e'_3.h.e'_3
α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ (range fun i => lift.{u, v} (f i)) = lift.{u, v} '' range f
state_after: no goals
tactic: simp_rw [← comp_apply (f := lift), range_comp]
Theorem: Nat.decreasingInduction_succ
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → m ≤ n + 1 → Sort u_1
of_succ : (k : ℕ) → (h : k < n + 1) → motive (k + 1) h → motive k ⋯
self : motive (n + 1) ⋯
mn : m ≤ n
msn : m ≤ n + 1
⊢ decreasingInduction of_succ self msn = decreasingInduction (fun i hi => of_succ i ⋯) (of_succ n ⋯ self) mn
state_after: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → m ≤ n + 1 → Sort u_1
of_succ : (k : ℕ) → (h : k < n + 1) → motive (k + 1) h → motive k ⋯
self : motive (n + 1) ⋯
mn : m ≤ n
msn : m ≤ n + 1
⊢ leRec (motive := fun {n} mn =>
      {motive : (m : ℕ) → m ≤ n → Sort u_1} →
        ((k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯) → motive n ⋯ → motive m mn)
      (fun {motive} of_succ self => self)
      (fun ⦃k⦄ h ih {motive} of_succ self => ih (fun i hi => of_succ i ⋯) (of_succ k ⋯ self)) msn of_succ self =
    leRec (motive := fun {n} mn =>
      {motive : (m : ℕ) → m ≤ n → Sort u_1} →
        ((k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯) → motive n ⋯ → motive m mn)
      (fun {motive} of_succ self => self)
      (fun ⦃k⦄ h ih {motive} of_succ self => ih (fun i hi => of_succ i ⋯) (of_succ k ⋯ self)) mn
      (fun i hi => of_succ i ⋯) (of_succ n ⋯ self)
tactic: dsimp only [decreasingInduction]
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
motive : (m : ℕ) → m ≤ n + 1 → Sort u_1
of_succ : (k : ℕ) → (h : k < n + 1) → motive (k + 1) h → motive k ⋯
self : motive (n + 1) ⋯
mn : m ≤ n
msn : m ≤ n + 1
⊢ leRec (motive := fun {n} mn =>
      {motive : (m : ℕ) → m ≤ n → Sort u_1} →
        ((k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯) → motive n ⋯ → motive m mn)
      (fun {motive} of_succ self => self)
      (fun ⦃k⦄ h ih {motive} of_succ self => ih (fun i hi => of_succ i ⋯) (of_succ k ⋯ self)) msn of_succ self =
    leRec (motive := fun {n} mn =>
      {motive : (m : ℕ) → m ≤ n → Sort u_1} →
        ((k : ℕ) → (h : k < n) → motive (k + 1) h → motive k ⋯) → motive n ⋯ → motive m mn)
      (fun {motive} of_succ self => self)
      (fun ⦃k⦄ h ih {motive} of_succ self => ih (fun i hi => of_succ i ⋯) (of_succ k ⋯ self)) mn
      (fun i hi => of_succ i ⋯) (of_succ n ⋯ self)
state_after: no goals
tactic: rw [leRec_succ]
Theorem: CategoryTheory.ShortComplex.moduleCatLeftHomologyData_i
File: Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ (LinearMap.ker S.g).subtype ≫ S.g = 0
state_after: case h.mk
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
val✝ : ↑S.X₂
hx : val✝ ∈ LinearMap.ker S.g
⊢ ((LinearMap.ker S.g).subtype ≫ S.g) ⟨val✝, hx⟩ = 0 ⟨val✝, hx⟩
tactic: ext ⟨_, hx⟩
state_before: case h.mk
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
val✝ : ↑S.X₂
hx : val✝ ∈ LinearMap.ker S.g
⊢ ((LinearMap.ker S.g).subtype ≫ S.g) ⟨val✝, hx⟩ = 0 ⟨val✝, hx⟩
state_after: no goals
tactic: exact hx
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ (ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯) ≫ S.moduleCatHomologyπ = 0
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯) ≫ S.moduleCatHomologyπ) x = 0 x
tactic: ext (x : S.X₁)
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯) ≫ S.moduleCatHomologyπ) x = 0 x
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ S.moduleCatHomologyπ (((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x) = 0 x
tactic: dsimp
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ S.moduleCatHomologyπ (((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x) = 0 x
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x ∈ LinearMap.range S.moduleCatToCycles
tactic: erw [Submodule.Quotient.mk_eq_zero]
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x ∈ LinearMap.range S.moduleCatToCycles
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ∃ y, S.moduleCatToCycles y = ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x
tactic: rw [LinearMap.mem_range]
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
x : ↑S.X₁
⊢ ∃ y, S.moduleCatToCycles y = ((ModuleCat.kernelIsLimit S.g).lift (KernelFork.ofι S.f ⋯)) x
state_after: no goals
tactic: apply exists_apply_eq_apply
Theorem: ProbabilityTheory.Kernel.withDensity_one
File: Mathlib/Probability/Kernel/WithDensity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
⊢ κ.withDensity 1 = κ
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
a✝¹ : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((κ.withDensity 1) a✝¹) s✝ = (κ a✝¹) s✝
tactic: ext
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
a✝¹ : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((κ.withDensity 1) a✝¹) s✝ = (κ a✝¹) s✝
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
a✝¹ : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((κ a✝¹).withDensity (1 a✝¹)) s✝ = (κ a✝¹) s✝
tactic: rw [Kernel.withDensity_apply _ measurable_const]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
a✝¹ : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((κ a✝¹).withDensity (1 a✝¹)) s✝ = (κ a✝¹) s✝
state_after: no goals
tactic: simp
Theorem: Computation.liftRel_of_mem
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a' b
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a b
tactic: rw [mem_unique ma' ma]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ ca
⊢ ∃ b, b ∈ cb ∧ R a b
state_after: no goals
tactic: exact ⟨b, mb, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b'
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b
tactic: rw [mem_unique mb' mb]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
b : β
ca : Computation α
cb : Computation β
ma : a ∈ ca
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ ∃ a, a ∈ ca ∧ R a b
state_after: no goals
tactic: exact ⟨a, ma, ab⟩
Theorem: MulChar.eq_iff
File: Mathlib/NumberTheory/MulChar/Lemmas.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
inst✝¹ : CommMonoid R
inst✝ : CommMonoidWithZero R'
g : Rˣ
hg : ∀ (x : Rˣ), x ∈ Subgroup.zpowers g
χ₁ χ₂ : MulChar R R'
⊢ χ₁ = χ₂ ↔ χ₁ ↑g = χ₂ ↑g
state_after: no goals
tactic: rw [← Equiv.apply_eq_iff_eq equivToUnitHom, MonoidHom.eq_iff_eq_on_generator hg,
    ← coe_equivToUnitHom, ← coe_equivToUnitHom, Units.ext_iff]
Theorem: mul_self_inj_of_nonneg
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a0 : 0 ≤ a
b0 : 0 ≤ b
h : a = -b
⊢ a = b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
⊢ -b = b
tactic: subst a
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
⊢ -b = b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
this : b = 0
⊢ -b = b
tactic: have : b = 0 := le_antisymm (neg_nonneg.1 a0) b0
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
this : b = 0
⊢ -b = b
state_after: no goals
tactic: rw [this, neg_zero]
Theorem: algebraMap_monotone
File: Mathlib/Algebra/Order/Algebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ (algebraMap R A) a ≤ (algebraMap R A) b
state_after: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 1
tactic: rw [Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one, ← sub_nonneg, ← sub_smul]
state_before: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 1
state_after: R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ 0 ≤ (b - a) • 0

R : Type u_1
A : Type u_2
a✝ b✝ : A
r : R
inst✝³ : OrderedCommRing R
inst✝² : OrderedRing A
inst✝¹ : Algebra R A
inst✝ : OrderedSMul R A
a b : R
h : a ≤ b
⊢ (b - a) • 0 ≤ (b - a) • 1
tactic: trans (b - a) • (0 : A)
Theorem: ZFSet.sInter_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: ⊢ ¬∅.Nonempty
state_after: no goals
tactic: simp
Theorem: SimplexCategory.δ_comp_σ_self'
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = i.castSucc
⊢ δ j ≫ σ i = 𝟙 [n]
state_after: n : ℕ
i : Fin (n + 1)
⊢ δ i.castSucc ≫ σ i = 𝟙 [n]
tactic: subst H
state_before: n : ℕ
i : Fin (n + 1)
⊢ δ i.castSucc ≫ σ i = 𝟙 [n]
state_after: no goals
tactic: rw [δ_comp_σ_self]
Theorem: List.IsInfix.trans
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
l l₁ r₁ l₂ r₂ : List α
⊢ l₂ ++ l₁ ++ l ++ (r₁ ++ r₂) = l₂ ++ (l₁ ++ l ++ r₁) ++ r₂
state_after: no goals
tactic: simp only [append_assoc]
Theorem: String.leftpad_prefix
File: Mathlib/Data/String/Lemmas.lean

Proof steps:
state_before: n : ℕ
c : Char
l : List Char
⊢ (replicate (n - { data := l }.length) c).IsPrefix (leftpad n c { data := l })
state_after: no goals
tactic: simp only [IsPrefix, replicate, leftpad, String.length, List.leftpad_prefix]
Theorem: Matrix.equiv_block_det
File: Mathlib/LinearAlgebra/Matrix/Block.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝⁶ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁵ : DecidableEq m
inst✝⁴ : Fintype m
inst✝³ : DecidableEq n
inst✝² : Fintype n
M : Matrix m m R
p q : m → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : ∀ (x : m), q x ↔ p x
⊢ (M.toSquareBlockProp p).det = (M.toSquareBlockProp q).det
state_after: no goals
tactic: convert Matrix.det_reindex_self (Equiv.subtypeEquivRight e) (toSquareBlockProp M q)
Theorem: LightCondSet.continuous_coinducingCoprod
File: Mathlib/Condensed/Light/TopCatAdjunction.lean

Proof steps:
state_before: X : LightCondSet
S : LightProfinite
x : X.val.obj (Opposite.op S)
⊢ Continuous fun a => LightCondSet.coinducingCoprod X ⟨⟨S, x⟩, a⟩
state_after: X : LightCondSet
S : LightProfinite
x : X.val.obj (Opposite.op S)
⊢ ∀ (i : (T : LightProfinite) × X.val.obj (Opposite.op T)), Continuous fun a => LightCondSet.coinducingCoprod X ⟨i, a⟩
tactic: suffices ∀ (i : (T : LightProfinite.{u}) × X.val.obj ⟨T⟩),
      Continuous (fun (a : i.fst) ↦ X.coinducingCoprod ⟨i, a⟩) from this ⟨_, _⟩
state_before: X : LightCondSet
S : LightProfinite
x : X.val.obj (Opposite.op S)
⊢ ∀ (i : (T : LightProfinite) × X.val.obj (Opposite.op T)), Continuous fun a => LightCondSet.coinducingCoprod X ⟨i, a⟩
state_after: X : LightCondSet
S : LightProfinite
x : X.val.obj (Opposite.op S)
⊢ Continuous (LightCondSet.coinducingCoprod X)
tactic: rw [← continuous_sigma_iff]
state_before: X : LightCondSet
S : LightProfinite
x : X.val.obj (Opposite.op S)
⊢ Continuous (LightCondSet.coinducingCoprod X)
state_after: no goals
tactic: apply continuous_coinduced_rng
Theorem: padicValRat.pow
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q ≠ 0
k : ℕ
⊢ padicValRat p (q ^ k) = ↑k * padicValRat p q
state_after: no goals
tactic: induction k <;>
    simp [*, padicValRat.mul hq (pow_ne_zero _ hq), _root_.pow_succ', add_mul, add_comm]
Theorem: MonoidAlgebra.of_mem_span_of_iff
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
⊢ (of R M) m ∈ span R (⇑(of R M) '' S) ↔ m ∈ S
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : (of R M) m ∈ span R (⇑(of R M) '' S)
⊢ m ∈ S
tactic: refine ⟨fun h => ?_, fun h => Submodule.subset_span <| Set.mem_image_of_mem (of R M) h⟩
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : (of R M) m ∈ span R (⇑(of R M) '' S)
⊢ m ∈ S
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S
tactic: erw [of, MonoidHom.coe_mk, ← Finsupp.supported_eq_span_single, Finsupp.mem_supported,
    Finsupp.support_single_ne_zero _ (one_ne_zero' R)] at h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : Monoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S
state_after: no goals
tactic: simpa using h
Theorem: Filter.Germ.isConstant_comp_tendsto
File: Mathlib/Order/Filter/Germ/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g✝ h : α → β
lc : Filter γ
g : γ → α
hf : (↑f).IsConstant
hg : Tendsto g lc l
⊢ (↑(f ∘ g)).IsConstant
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g✝ h : α → β
lc : Filter γ
g : γ → α
hg : Tendsto g lc l
b : β
hb : f =ᶠ[l] fun x => b
⊢ (↑(f ∘ g)).IsConstant
tactic: rcases hf with ⟨b, hb⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f g✝ h : α → β
lc : Filter γ
g : γ → α
hg : Tendsto g lc l
b : β
hb : f =ᶠ[l] fun x => b
⊢ (↑(f ∘ g)).IsConstant
state_after: no goals
tactic: exact ⟨b, hb.comp_tendsto hg⟩
Theorem: Valuation.isEquiv_iff_val_lt_one
File: Mathlib/RingTheory/Valuation/Basic.lean

Proof steps:
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ v.IsEquiv v' ↔ ∀ {x : K}, v x < 1 ↔ v' x < 1
state_after: case mp
K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ v.IsEquiv v' → ∀ {x : K}, v x < 1 ↔ v' x < 1

case mpr
K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : LinearOrderedCommGroupWithZero Γ'₀
v : Valuation K Γ₀
v' : Valuation K Γ'₀
⊢ (∀ {x : K}, v x < 1 ↔ v' x < 1) → v.IsEquiv v'
tactic: constructor
Theorem: Equiv.Perm.toList_formPerm_singleton
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ x y : α
⊢ [x].formPerm.toList y = []
state_after: no goals
tactic: simp
Theorem: Int.dvd_mul_of_div_dvd
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
h : b ∣ a
hdiv : a / b ∣ c
⊢ a ∣ b * c
state_after: case intro
a b d m n : ℤ
h : b ∣ a
e : ℤ
⊢ a ∣ b * (a / b * e)
tactic: obtain ⟨e, rfl⟩ := hdiv
state_before: case intro
a b d m n : ℤ
h : b ∣ a
e : ℤ
⊢ a ∣ b * (a / b * e)
state_after: case intro
a b d m n : ℤ
h : b ∣ a
e : ℤ
⊢ a ∣ a * e
tactic: rw [← Int.mul_assoc, Int.mul_comm _ (a / b), Int.ediv_mul_cancel h]
state_before: case intro
a b d m n : ℤ
h : b ∣ a
e : ℤ
⊢ a ∣ a * e
state_after: no goals
tactic: exact Int.dvd_mul_right a e
Theorem: LieModule.isLieAbelian_of_ker_traceForm_eq_bot
File: Mathlib/Algebra/Lie/TraceForm.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : LieAlgebra.IsNilpotent R L
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
h : LinearMap.ker (traceForm R L M) = ⊥
⊢ IsLieAbelian L
state_after: no goals
tactic: simpa only [← disjoint_lowerCentralSeries_maxTrivSubmodule_iff R L L, disjoint_iff_inf_le,
    LieIdeal.coe_to_lieSubalgebra_to_submodule, LieSubmodule.coeSubmodule_eq_bot_iff, h]
    using lowerCentralSeries_one_inf_center_le_ker_traceForm R L M
Theorem: CategoryTheory.Injective.of_iso
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
⊢ ∃ h, f ≫ h = g
state_after: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
h : Y✝ ⟶ P
h_eq : f ≫ h = g ≫ i.inv
⊢ ∃ h, f ≫ h = g
tactic: obtain ⟨h, h_eq⟩ := @Injective.factors C _ P _ _ _ (g ≫ i.inv) f mono
state_before: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
h : Y✝ ⟶ P
h_eq : f ≫ h = g ≫ i.inv
⊢ ∃ h, f ≫ h = g
state_after: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
h : Y✝ ⟶ P
h_eq : f ≫ h = g ≫ i.inv
⊢ f ≫ h ≫ i.hom = g
tactic: refine ⟨h ≫ i.hom, ?_⟩
state_before: case intro
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q : C
i : P ≅ Q
hP : Injective P
X✝ Y✝ : C
g : X✝ ⟶ Q
f : X✝ ⟶ Y✝
mono : Mono f
h : Y✝ ⟶ P
h_eq : f ≫ h = g ≫ i.inv
⊢ f ≫ h ≫ i.hom = g
state_after: no goals
tactic: rw [← Category.assoc, h_eq, Category.assoc, Iso.inv_hom_id, Category.comp_id]