ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PFunctor.M.isPath_cons
File: Mathlib/Data/PFunctor/Univariate/M.lean

Proof steps:
state_before: F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
xs : Path F
a a' : F.A
f : F.B a → F.M
i : F.B a'
⊢ IsPath (⟨a', i⟩ :: xs) (M.mk ⟨a, f⟩) → a = a'
state_after: F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
xs : Path F
a a' : F.A
f : F.B a → F.M
i : F.B a'
x : F.M
h : M.mk ⟨a, f⟩ = x
⊢ IsPath (⟨a', i⟩ :: xs) x → a = a'
tactic: generalize h : M.mk ⟨a, f⟩ = x
state_before: F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
xs : Path F
a a' : F.A
f : F.B a → F.M
i : F.B a'
x : F.M
h : M.mk ⟨a, f⟩ = x
⊢ IsPath (⟨a', i⟩ :: xs) x → a = a'
state_after: case cons
F : PFunctor.{u}
X : Type u_1
f✝¹ : X → ↑F X
xs : Path F
a a' : F.A
f : F.B a → F.M
i : F.B a'
f✝ : F.B a' → F.M
a✝ : IsPath xs (f✝ i)
h : M.mk ⟨a, f⟩ = M.mk ⟨a', f✝⟩
⊢ a = a'
tactic: rintro (_ | ⟨_, _, _, _, rfl, _⟩)
state_before: case cons
F : PFunctor.{u}
X : Type u_1
f✝¹ : X → ↑F X
xs : Path F
a a' : F.A
f : F.B a → F.M
i : F.B a'
f✝ : F.B a' → F.M
a✝ : IsPath xs (f✝ i)
h : M.mk ⟨a, f⟩ = M.mk ⟨a', f✝⟩
⊢ a = a'
state_after: case cons.refl
F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
xs : Path F
a : F.A
f : F.B a → F.M
i : F.B a
a✝ : IsPath xs (f i)
h : M.mk ⟨a, f⟩ = M.mk ⟨a, f⟩
⊢ a = a
tactic: cases mk_inj h
state_before: case cons.refl
F : PFunctor.{u}
X : Type u_1
f✝ : X → ↑F X
xs : Path F
a : F.A
f : F.B a → F.M
i : F.B a
a✝ : IsPath xs (f i)
h : M.mk ⟨a, f⟩ = M.mk ⟨a, f⟩
⊢ a = a
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.Walk.length_support
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.support.length = p.length + 1
state_after: no goals
tactic: induction p <;> simp [*]
Theorem: EuclideanGeometry.oangle_swap₁₃_sign
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ -(∡ p₁ p₂ p₃).sign = (∡ p₃ p₂ p₁).sign
state_after: no goals
tactic: rw [oangle_rev, Real.Angle.sign_neg, neg_neg]
Theorem: finrank_le_one
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : StrongRankCondition R
v : M
h : ∀ (w : M), ∃ c, c • v = w
⊢ finrank R M ≤ 1
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : StrongRankCondition R
v : M
h : ∀ (w : M), ∃ c, c • v = w
this : Nontrivial R
⊢ finrank R M ≤ 1
tactic: haveI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : StrongRankCondition R
v : M
h : ∀ (w : M), ∃ c, c • v = w
this : Nontrivial R
⊢ finrank R M ≤ 1
state_after: case inl
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : StrongRankCondition R
this : Nontrivial R
h : ∀ (w : M), ∃ c, c • 0 = w
⊢ finrank R M ≤ 1

case inr
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : StrongRankCondition R
v : M
h : ∀ (w : M), ∃ c, c • v = w
this : Nontrivial R
hn : v ≠ 0
⊢ finrank R M ≤ 1
tactic: rcases eq_or_ne v 0 with (rfl | hn)
Theorem: DFinsupp.prod_subtypeDomain_index
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → Zero (β i)
inst✝² : (i : ι) → (x : β i) → Decidable (x ≠ 0)
inst✝¹ : CommMonoid γ
v : Π₀ (i : ι), β i
p : ι → Prop
inst✝ : DecidablePred p
h : (i : ι) → β i → γ
hp : ∀ x ∈ v.support, p x
⊢ ((subtypeDomain p v).prod fun i b => h (↑i) b) = v.prod h
state_after: no goals
tactic: refine Finset.prod_bij (fun p _ ↦ p) ?_ ?_ ?_ ?_ <;> aesop
Theorem: Fin.exists_eq_add_of_lt
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
a b : Fin (n + 1)
h : a < b
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
state_after: case zero
n m : ℕ
a b : Fin (0 + 1)
h : a < b
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1

case succ
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
tactic: cases n
state_before: case succ
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
state_after: case succ.intro
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
tactic: obtain ⟨k, hk⟩ : ∃ k : ℕ, (b : ℕ) = a + k + 1 := Nat.exists_eq_add_of_lt h
state_before: case succ.intro
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
state_after: case succ.intro
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
hkb : k < ↑b
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
tactic: have hkb : k < b := by omega
state_before: case succ.intro
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
hkb : k < ↑b
⊢ ∃ k < b, k + 1 ≤ b ∧ b = a + k + 1
state_after: case succ.intro.refine_1
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
hkb : k < ↑b
⊢ ⟨k, ⋯⟩ + 1 ≤ b

case succ.intro.refine_2
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
hkb : k < ↑b
⊢ b = a + ⟨k, ⋯⟩ + 1
tactic: refine ⟨⟨k, hkb.trans b.is_lt⟩, hkb, ?_, ?_⟩
state_before: case succ.intro.refine_2
n m n✝ : ℕ
a b : Fin (n✝ + 1 + 1)
h : a < b
k : ℕ
hk : ↑b = ↑a + k + 1
hkb : k < ↑b
⊢ b = a + ⟨k, ⋯⟩ + 1
state_after: no goals
tactic: simp [Fin.ext_iff, Fin.val_add, ← hk, Nat.mod_eq_of_lt b.is_lt]
Theorem: CochainComplex.mappingCone.δ_inl
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.104131, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
⊢ δ (-1) 0 (inl φ) = Cochain.ofHom (φ ≫ inr φ)
state_after: case h
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.104131, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p : ℤ
⊢ (δ (-1) 0 (inl φ)).v p p ⋯ = (Cochain.ofHom (φ ≫ inr φ)).v p p ⋯
tactic: ext p
state_before: case h
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.104131, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p : ℤ
⊢ (δ (-1) 0 (inl φ)).v p p ⋯ = (Cochain.ofHom (φ ≫ inr φ)).v p p ⋯
state_after: no goals
tactic: simp [δ_v (-1) 0 (neg_add_self 1) (inl φ) p p (add_zero p) _ _ rfl rfl,
    inl_v_d φ p (p - 1) (p + 1) (by omega) (by omega)]
Theorem: ProbabilityTheory.IndepFun_iff_Indep
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
f : Ω → β
g : Ω → γ
μ : Measure Ω
⊢ IndepFun f g μ ↔ Indep (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) μ
state_after: no goals
tactic: simp only [IndepFun, Indep, Kernel.IndepFun]
Theorem: Function.Injective.map_swap
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
⊢ f ((Equiv.swap x y) z) = (Equiv.swap (f x) (f y)) (f z)
state_after: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
⊢ f ((Equiv.swap x y) z) = if f z = f x then f y else if f z = f y then f x else f z
tactic: conv_rhs => rw [Equiv.swap_apply_def]
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
⊢ f ((Equiv.swap x y) z) = if f z = f x then f y else if f z = f y then f x else f z
state_after: case pos
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
h₁ : f z = f x
⊢ f ((Equiv.swap x y) z) = f y

case pos
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
h₁ : ¬f z = f x
h₂ : f z = f y
⊢ f ((Equiv.swap x y) z) = f x

case neg
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
h₁ : ¬f z = f x
h₂ : ¬f z = f y
⊢ f ((Equiv.swap x y) z) = f z
tactic: split_ifs with h₁ h₂
Theorem: Function.disjoint_support_iff
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
s : Set α
⊢ Disjoint s (mulSupport f) ↔ EqOn f 1 s
state_after: no goals
tactic: rw [disjoint_comm, mulSupport_disjoint_iff]
Theorem: AlgHom.snd_prod
File: Mathlib/Algebra/Algebra/Prod.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
⊢ (snd R B C).comp (f.prod g) = g
state_after: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ((snd R B C).comp (f.prod g)) x✝ = g x✝
tactic: ext
state_before: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ((snd R B C).comp (f.prod g)) x✝ = g x✝
state_after: no goals
tactic: rfl
Theorem: Nat.factorization_zero
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a b m n p : ℕ
⊢ factorization 0 = 0
state_after: case h
a b m n p a✝ : ℕ
⊢ (factorization 0) a✝ = 0 a✝
tactic: ext
state_before: case h
a b m n p a✝ : ℕ
⊢ (factorization 0) a✝ = 0 a✝
state_after: no goals
tactic: simp [factorization]
Theorem: Uniform.continuousOn_iff'_left
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
s : Set β
⊢ ContinuousOn f s ↔ ∀ b ∈ s, Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α)
state_after: no goals
tactic: simp [ContinuousOn, continuousWithinAt_iff'_left]
Theorem: Complex.rank_real_complex'
File: Mathlib/Data/Complex/FiniteDimensional.lean

Proof steps:
state_before: ⊢ Cardinal.lift.{u, 0} (Module.rank ℝ ℂ) = 2
state_after: no goals
tactic: rw [← finrank_eq_rank, finrank_real_complex, Cardinal.lift_natCast, Nat.cast_ofNat]
Theorem: expNegInvGlue.zero_of_nonpos
File: Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean

Proof steps:
state_before: x : ℝ
hx : x ≤ 0
⊢ expNegInvGlue x = 0
state_after: no goals
tactic: simp [expNegInvGlue, hx]
Theorem: ProbabilityTheory.Kernel.compProd_restrict_left
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ κ.restrict hs ⊗ₖ η = (κ ⊗ₖ η).restrict ⋯
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ κ.restrict hs ⊗ₖ η = κ.restrict ?hs ⊗ₖ η.restrict ?ht

case hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet s

case ht
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet Set.univ
tactic: rw [← compProd_restrict]
Theorem: Finset.weightedVSubOfPoint_insert
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ ((insert i s).weightedVSubOfPoint p (p i)) w = (s.weightedVSubOfPoint p (p i)) w
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ ∑ i_1 ∈ insert i s, w i_1 • (p i_1 -ᵥ p i) = ∑ i_1 ∈ s, w i_1 • (p i_1 -ᵥ p i)
tactic: rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ ∑ i_1 ∈ insert i s, w i_1 • (p i_1 -ᵥ p i) = ∑ i_1 ∈ s, w i_1 • (p i_1 -ᵥ p i)
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ w i • (p i -ᵥ p i) = 0
tactic: apply sum_insert_zero
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
w : ι → k
p : ι → P
i : ι
⊢ w i • (p i -ᵥ p i) = 0
state_after: no goals
tactic: rw [vsub_self, smul_zero]
Theorem: Nat.rfind_min'
File: Mathlib/Computability/Partrec.lean

Proof steps:
state_before: p : ℕ → Bool
m : ℕ
pm : p m = true
this : true ∈ ↑p m
n : ℕ
hn : n ∈ rfind ↑p
h : m < n
⊢ False
state_after: no goals
tactic: injection mem_unique this (rfind_min hn h)
Theorem: Sum.update_inl_apply_inl
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq (α ⊕ β)
f : α ⊕ β → γ
i j : α
x : γ
⊢ update f (inl i) x (inl j) = update (f ∘ inl) i x j
state_after: no goals
tactic: rw [← update_inl_comp_inl, Function.comp_apply]
Theorem: List.count_singleton
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
⊢ count a [a] = 1
state_after: no goals
tactic: simp
Theorem: Set.image2_right
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
h : s.Nonempty
⊢ image2 (fun x y => y) s t = t
state_after: no goals
tactic: simp [nonempty_def.mp h, Set.ext_iff]
Theorem: MvPolynomial.pderiv_C_mul
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

Proof steps:
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
f : MvPolynomial σ R
i : σ
⊢ (pderiv i) (C a * f) = C a * (pderiv i) f
state_after: no goals
tactic: rw [C_mul', Derivation.map_smul, C_mul']
Theorem: LinearLocallyFiniteOrder.succFn_le_of_lt
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
⊢ succFn i ≤ j
state_after: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
h : IsGLB (Set.Ioi i) (succFn i)
⊢ succFn i ≤ j
tactic: have h := succFn_spec i
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
h : IsGLB (Set.Ioi i) (succFn i)
⊢ succFn i ≤ j
state_after: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
h : (∀ x ∈ Set.Ioi i, succFn i ≤ x) ∧ succFn i ∈ upperBounds (lowerBounds (Set.Ioi i))
⊢ succFn i ≤ j
tactic: rw [IsGLB, IsGreatest, mem_lowerBounds] at h
state_before: ι : Type u_1
inst✝ : LinearOrder ι
i j : ι
hij : i < j
h : (∀ x ∈ Set.Ioi i, succFn i ≤ x) ∧ succFn i ∈ upperBounds (lowerBounds (Set.Ioi i))
⊢ succFn i ≤ j
state_after: no goals
tactic: exact h.1 j hij
Theorem: dist_le_norm_add_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist a b ≤ ‖a‖ + ‖b‖
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a / b‖ ≤ ‖a‖ + ‖b‖
tactic: rw [dist_eq_norm_div]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ ‖a / b‖ ≤ ‖a‖ + ‖b‖
state_after: no goals
tactic: apply norm_div_le
Theorem: Fintype.card_range_le
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β✝
α : Type u_4
β : Type u_5
f : α → β
inst✝¹ : Fintype α
inst✝ : Fintype ↑(Set.range f)
a : α
⊢ f a ∈ Set.range f
state_after: no goals
tactic: simp
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
inst✝² : Fintype β✝
α : Type u_4
β : Type u_5
f : α → β
inst✝¹ : Fintype α
inst✝ : Fintype ↑(Set.range f)
x✝ : ↑(Set.range f)
val✝ : β
a : α
ha : f a = val✝
⊢ (fun a => ⟨f a, ⋯⟩) a = ⟨val✝, ⋯⟩
state_after: no goals
tactic: simpa using ha
Theorem: cfc_map_div
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : Semifield R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : HasContinuousInv₀ R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ : R → R
a✝ : A
f g : R → R
a : A
hg' : ∀ x ∈ spectrum R a, g x ≠ 0
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f x / g x) a = cfc f a * Ring.inverse (cfc g a)
state_after: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : Semifield R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : HasContinuousInv₀ R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ : R → R
a✝ : A
f g : R → R
a : A
hg' : ∀ x ∈ spectrum R a, g x ≠ 0
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f x * (g x)⁻¹) a = cfc f a * Ring.inverse (cfc g a)
tactic: simp only [div_eq_mul_inv]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : Semifield R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : HasContinuousInv₀ R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ : R → R
a✝ : A
f g : R → R
a : A
hg' : ∀ x ∈ spectrum R a, g x ≠ 0
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f x * (g x)⁻¹) a = cfc f a * Ring.inverse (cfc g a)
state_after: no goals
tactic: rw [cfc_mul .., cfc_inv g a hg']
Theorem: List.forall_tfae
File: Mathlib/Data/List/TFAE.lean

Proof steps:
state_before: α : Type u_1
l : List (α → Prop)
H : ∀ (a : α), (map (fun p => p a) l).TFAE
⊢ (map (fun p => ∀ (a : α), p a) l).TFAE
state_after: α : Type u_1
l : List (α → Prop)
H : ∀ (a : α), (map (fun p => p a) l).TFAE
⊢ ∀ (j : α → Prop), j ∈ l → ∀ (j_1 : α → Prop), j_1 ∈ l → ((∀ (a : α), j a) ↔ ∀ (a : α), j_1 a)
tactic: simp only [TFAE, List.forall_mem_map_iff]
state_before: α : Type u_1
l : List (α → Prop)
H : ∀ (a : α), (map (fun p => p a) l).TFAE
⊢ ∀ (j : α → Prop), j ∈ l → ∀ (j_1 : α → Prop), j_1 ∈ l → ((∀ (a : α), j a) ↔ ∀ (a : α), j_1 a)
state_after: α : Type u_1
l : List (α → Prop)
H : ∀ (a : α), (map (fun p => p a) l).TFAE
p₁ : α → Prop
hp₁ : p₁ ∈ l
p₂ : α → Prop
hp₂ : p₂ ∈ l
⊢ (∀ (a : α), p₁ a) ↔ ∀ (a : α), p₂ a
tactic: intros p₁ hp₁ p₂ hp₂
state_before: α : Type u_1
l : List (α → Prop)
H : ∀ (a : α), (map (fun p => p a) l).TFAE
p₁ : α → Prop
hp₁ : p₁ ∈ l
p₂ : α → Prop
hp₂ : p₂ ∈ l
⊢ (∀ (a : α), p₁ a) ↔ ∀ (a : α), p₂ a
state_after: no goals
tactic: exact forall_congr' fun a ↦ H a (p₁ a) (mem_map_of_mem (fun p ↦ p a) hp₁)
    (p₂ a) (mem_map_of_mem (fun p ↦ p a) hp₂)
Theorem: Complex.sinh_conj
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ sinh ((starRingEnd ℂ) x) = (starRingEnd ℂ) (sinh x)
state_after: x y : ℂ
⊢ (starRingEnd ℂ) (cexp x - cexp (-x)) / 2 = (starRingEnd ℂ) (cexp x - cexp (-x)) / (starRingEnd ℂ) 2
tactic: rw [sinh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_sub, sinh, map_div₀]
state_before: x y : ℂ
⊢ (starRingEnd ℂ) (cexp x - cexp (-x)) / 2 = (starRingEnd ℂ) (cexp x - cexp (-x)) / (starRingEnd ℂ) 2
state_after: no goals
tactic: simp [← one_add_one_eq_two]
Theorem: SimplexCategory.δ_comp_σ_of_gt'
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : j.succ < i
hi : i = 0
⊢ False
state_after: no goals
tactic: simp only [Fin.not_lt_zero, hi] at H
state_before: n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : j.succ < i
⊢ δ i ≫ σ j = σ (j.castLT ⋯) ≫ δ (i.pred ⋯)
state_after: n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : j.succ < i
⊢ δ i ≫ σ j = δ (i.pred ⋯).succ ≫ σ (j.castLT ⋯).castSucc

n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : j.succ < i
⊢ (j.castLT ⋯).castSucc < i.pred ⋯
tactic: rw [← δ_comp_σ_of_gt]