ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Associated.of_mul_left
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ a * (b * ↑(u * v)) = a * d
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ c * ↑v * (b * ↑(u * v)) = ↑v * (a * b * ↑u)
tactic: rw [← hv, mul_assoc c (v : α) d, mul_left_comm c, ← hu]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
h : a * b ~ᵤ c * d
h₁ : a ~ᵤ c
ha : a ≠ 0
u : αˣ
hu : a * b * ↑u = c * d
v : αˣ
hv : c * ↑v = a
⊢ c * ↑v * (b * ↑(u * v)) = ↑v * (a * b * ↑u)
state_after: no goals
tactic: simp [hv.symm, mul_assoc, mul_comm, mul_left_comm]
Theorem: mul_inv_le_mul_inv_iff'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b
state_after: no goals
tactic: rw [mul_comm c, mul_inv_le_inv_mul_iff, mul_comm]
Theorem: cfcₙ_zero
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a : A
hf : autoParam (ContinuousOn f (σₙ R a)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfcₙ 0 a = 0
state_after: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a : A
hf : autoParam (ContinuousOn f (σₙ R a)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a) _auto✝
ha : p a
⊢ cfcₙ 0 a = 0

case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f g : R → R
a : A
hf : autoParam (ContinuousOn f (σₙ R a)) _auto✝
hf0 : autoParam (f 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a) _auto✝
ha : ¬p a
⊢ cfcₙ 0 a = 0
tactic: by_cases ha : p a
Theorem: Finset.not_nontrivial_empty
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a b : α
⊢ ¬∅.Nontrivial
state_after: no goals
tactic: simp [Finset.Nontrivial]
Theorem: _private.Mathlib.Analysis.InnerProductSpace.OfNorm.0.InnerProductSpaceable.nat_prop
File: Mathlib/Analysis/InnerProductSpace/OfNorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℕ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = (starRingEnd 𝕜) ↑r * inner_ 𝕜 x y
state_after: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℕ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = ↑r * inner_ 𝕜 x y
tactic: simp only [map_natCast]
state_before: 𝕜 : Type u_1
inst✝³ : RCLike 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : InnerProductSpaceable E
r : ℕ
x y : E
⊢ inner_ 𝕜 (↑r • x) y = ↑r * inner_ 𝕜 x y
state_after: no goals
tactic: exact nat r x y
Theorem: List.next_reverse_eq_prev
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : l.Nodup
x : α
hx : x ∈ l
⊢ l.reverse.next x ⋯ = l.prev x hx
state_after: case h.e'_3.h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : l.Nodup
x : α
hx : x ∈ l
⊢ l = l.reverse.reverse
tactic: convert (prev_reverse_eq_next l.reverse (nodup_reverse.mpr h) x (mem_reverse.mpr hx)).symm
state_before: case h.e'_3.h.e'_3
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
h : l.Nodup
x : α
hx : x ∈ l
⊢ l = l.reverse.reverse
state_after: no goals
tactic: exact (reverse_reverse l).symm
Theorem: Ordinal.opow_limit
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: a b : Ordinal.{u}
a0 : a ≠ 0
h : b.IsLimit
⊢ a ^ b = b.bsup fun c x => a ^ c
state_after: a b : Ordinal.{u}
a0 : a ≠ 0
h : b.IsLimit
⊢ (b.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup) =
    b.bsup fun c x => c.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup
tactic: simp only [opow_def, if_neg a0]
state_before: a b : Ordinal.{u}
a0 : a ≠ 0
h : b.IsLimit
⊢ (b.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup) =
    b.bsup fun c x => c.limitRecOn 1 (fun x IH => IH * a) fun b x => b.bsup
state_after: no goals
tactic: rw [limitRecOn_limit _ _ _ _ h]
Theorem: Multiset.measurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
s : Multiset (α → M)
hs : ∀ f ∈ s, Measurable f
⊢ Measurable fun x => (map (fun f => f x) s).prod
state_after: no goals
tactic: simpa only [← Pi.multiset_prod_apply] using s.measurable_prod' hs
Theorem: Nat.even_iff
File: Mathlib/Algebra/Group/Nat.lean

Proof steps:
state_before: m✝ n : ℕ
x✝ : Even n
m : ℕ
hm : n = m + m
⊢ n % 2 = 0
state_after: no goals
tactic: simp [← Nat.two_mul, hm]
state_before: m n : ℕ
h : n % 2 = 0
⊢ n % 2 + 2 * (n / 2) = n / 2 + n / 2
state_after: no goals
tactic: simp [← Nat.two_mul, h]
Theorem: ContinuousLinearMap.iSup_rayleigh_eq_iSup_rayleigh_sphere
File: Mathlib/Analysis/InnerProductSpace/Rayleigh.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →L[𝕜] E
r : ℝ
hr : 0 < r
⊢ ⨆ x, T.rayleighQuotient ↑x = ⨆ x, T.rayleighQuotient ↑x
state_after: no goals
tactic: simp only [← @sSup_image' _ _ _ _ (rayleighQuotient T),
      T.image_rayleigh_eq_image_rayleigh_sphere hr]
Theorem: IsLocalMaxOn.fderivWithin_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

Proof steps:
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
h : IsLocalMaxOn f s a
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ (fderivWithin ℝ f s a) y = 0
state_after: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
h : IsLocalMaxOn f s a
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ 0 y = 0
tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt hf]
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
h : IsLocalMaxOn f s a
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
hf : ¬DifferentiableWithinAt ℝ f s a
⊢ 0 y = 0
state_after: no goals
tactic: rfl
Theorem: Continuous.matrix_fromBlocks
File: Mathlib/Topology/Instances/Matrix.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
l : Type u_3
m : Type u_4
n : Type u_5
p : Type u_6
S : Type u_7
R : Type u_8
m' : l → Type u_9
n' : l → Type u_10
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace R
A : X → Matrix n l R
B : X → Matrix n m R
C : X → Matrix p l R
D : X → Matrix p m R
hA : Continuous A
hB : Continuous B
hC : Continuous C
hD : Continuous D
⊢ ∀ (i : n ⊕ p) (j : l ⊕ m), Continuous fun a => fromBlocks (A a) (B a) (C a) (D a) i j
state_after: no goals
tactic: rintro (i | i) (j | j) <;> refine Continuous.matrix_elem ?_ i j <;> assumption
Theorem: NormedSpace.Dual.dual_norm_topology_le_weak_dual_topology
File: Mathlib/Analysis/Normed/Module/WeakDual.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ UniformSpace.toTopologicalSpace ≤ WeakDual.instTopologicalSpace
state_after: case h.e'_4
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ WeakDual.instTopologicalSpace = TopologicalSpace.induced (fun x' => toWeakDual x') WeakDual.instTopologicalSpace
tactic: convert (@toWeakDual_continuous _ _ _ _ (by assumption)).le_induced
state_before: case h.e'_4
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ WeakDual.instTopologicalSpace = TopologicalSpace.induced (fun x' => toWeakDual x') WeakDual.instTopologicalSpace
state_after: no goals
tactic: exact induced_id.symm
Theorem: summable_one_div_pow_of_le
File: Mathlib/Analysis/SpecificLimits/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : ℝ
f : ℕ → ℕ
hm : 1 < m
fi : ∀ (i : ℕ), i ≤ f i
⊢ Summable fun i => 1 / m ^ f i
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
m : ℝ
f : ℕ → ℕ
hm : 1 < m
fi : ∀ (i : ℕ), i ≤ f i
a : ℕ
⊢ 1 / m ^ f a ≤ (1 / m) ^ a
tactic: refine .of_nonneg_of_le (fun a ↦ by positivity) (fun a ↦ ?_)
      (summable_geometric_of_lt_one (one_div_nonneg.mpr (zero_le_one.trans hm.le))
        ((one_div_lt (zero_lt_one.trans hm) zero_lt_one).mpr (one_div_one.le.trans_lt hm)))
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : ℝ
f : ℕ → ℕ
hm : 1 < m
fi : ∀ (i : ℕ), i ≤ f i
a : ℕ
⊢ 1 / m ^ f a ≤ (1 / m) ^ a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
m : ℝ
f : ℕ → ℕ
hm : 1 < m
fi : ∀ (i : ℕ), i ≤ f i
a : ℕ
⊢ 1 / m ^ f a ≤ 1 / m ^ a
tactic: rw [div_pow, one_pow]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : ℝ
f : ℕ → ℕ
hm : 1 < m
fi : ∀ (i : ℕ), i ≤ f i
a : ℕ
⊢ 1 / m ^ f a ≤ 1 / m ^ a
state_after: no goals
tactic: refine (one_div_le_one_div ?_ ?_).mpr (pow_le_pow_right hm.le (fi a)) <;>
    exact pow_pos (zero_lt_one.trans hm) _
Theorem: Finsupp.mapDomain_injOn
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S✝ : Type u_12
inst✝ : AddCommMonoid M
v v₁ v₂ : α →₀ M
S : Set α
f : α → β
hf : Set.InjOn f S
⊢ Set.InjOn (mapDomain f) {w | ↑w.support ⊆ S}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S✝ : Type u_12
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
S : Set α
f : α → β
hf : Set.InjOn f S
v₁ : α →₀ M
hv₁ : v₁ ∈ {w | ↑w.support ⊆ S}
v₂ : α →₀ M
hv₂ : v₂ ∈ {w | ↑w.support ⊆ S}
eq : mapDomain f v₁ = mapDomain f v₂
⊢ v₁ = v₂
tactic: intro v₁ hv₁ v₂ hv₂ eq
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S✝ : Type u_12
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
S : Set α
f : α → β
hf : Set.InjOn f S
v₁ : α →₀ M
hv₁ : v₁ ∈ {w | ↑w.support ⊆ S}
v₂ : α →₀ M
hv₂ : v₂ ∈ {w | ↑w.support ⊆ S}
eq : mapDomain f v₁ = mapDomain f v₂
⊢ v₁ = v₂
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S✝ : Type u_12
inst✝ : AddCommMonoid M
v v₁✝ v₂✝ : α →₀ M
S : Set α
f : α → β
hf : Set.InjOn f S
v₁ : α →₀ M
hv₁ : v₁ ∈ {w | ↑w.support ⊆ S}
v₂ : α →₀ M
hv₂ : v₂ ∈ {w | ↑w.support ⊆ S}
eq : mapDomain f v₁ = mapDomain f v₂
a : α
⊢ v₁ a = v₂ a
tactic: ext a
Theorem: dite_le_one
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
⊢ dite p a b ≤ 1
state_after: case isTrue
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : p
⊢ a h✝ ≤ 1

case isFalse
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : ¬p
⊢ b h✝ ≤ 1
tactic: split
state_before: case isTrue
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : p
⊢ a h✝ ≤ 1

case isFalse
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : ¬p
⊢ b h✝ ≤ 1
state_after: no goals
tactic: exacts [ha ‹_›, hb ‹_›]
Theorem: Finset.sum_powerset_apply_card
File: Mathlib/Data/Nat/Choose/Sum.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
inst✝ : AddCommMonoid α
f : ℕ → α
x : Finset β
⊢ ∑ m ∈ x.powerset, f m.card = ∑ m ∈ range (x.card + 1), x.card.choose m • f m
state_after: R : Type u_1
α : Type u_2
β : Type u_3
inst✝ : AddCommMonoid α
f : ℕ → α
x : Finset β
⊢ ∑ m ∈ x.powerset, f m.card = ∑ m ∈ range (x.card + 1), ∑ j ∈ filter (fun z => z.card = m) x.powerset, f j.card

R : Type u_1
α : Type u_2
β : Type u_3
inst✝ : AddCommMonoid α
f : ℕ → α
x : Finset β
⊢ ∑ m ∈ range (x.card + 1), ∑ j ∈ filter (fun z => z.card = m) x.powerset, f j.card =
    ∑ m ∈ range (x.card + 1), x.card.choose m • f m
tactic: trans ∑ m ∈ range (x.card + 1), ∑ j ∈ x.powerset.filter fun z ↦ z.card = m, f j.card
Theorem: Algebra.TensorProduct.tmul_pow
File: Mathlib/RingTheory/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
a : A
b : B
k : ℕ
⊢ a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k)
state_after: case zero
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
a : A
b : B
⊢ a ⊗ₜ[R] b ^ 0 = (a ^ 0) ⊗ₜ[R] (b ^ 0)

case succ
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
a : A
b : B
k : ℕ
ih : a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k)
⊢ a ⊗ₜ[R] b ^ (k + 1) = (a ^ (k + 1)) ⊗ₜ[R] (b ^ (k + 1))
tactic: induction' k with k ih
Theorem: Polynomial.natDegree_divX_eq_natDegree_tsub_one
File: Mathlib/Algebra/Polynomial/Inductions.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ p.divX.natDegree = p.natDegree - 1
state_after: case φ_k
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ∀ (f : R[X]), f.natDegree < 1 → divX_hom f = 0

case φ_mon
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → (divX_hom ((monomial n) c)).natDegree = n - 1
tactic: apply map_natDegree_eq_sub (φ := divX_hom)
Theorem: Rat.normalize_zero
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: d : Nat
nz : d ≠ 0
⊢ normalize 0 d nz = 0
state_after: d : Nat
nz : d ≠ 0
⊢ ↑0 = 0
tactic: simp [normalize, Int.zero_div, Int.natAbs_zero, Nat.div_self (Nat.pos_of_ne_zero nz)]
state_before: d : Nat
nz : d ≠ 0
⊢ ↑0 = 0
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.IdentDistrib.essSup_eq
File: Mathlib/Probability/IdentDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝³ : ConditionallyCompleteLinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : OrderClosedTopology γ
h : IdentDistrib f g μ ν
⊢ essSup f μ = essSup g ν
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝³ : ConditionallyCompleteLinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : OrderClosedTopology γ
h : IdentDistrib f g μ ν
I : ∀ (a : γ), μ {x | a < f x} = ν {x | a < g x}
⊢ essSup f μ = essSup g ν
tactic: have I : ∀ a, μ {x : α | a < f x} = ν {x : β | a < g x} := fun a =>
    h.measure_mem_eq measurableSet_Ioi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝³ : ConditionallyCompleteLinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : OrderClosedTopology γ
h : IdentDistrib f g μ ν
I : ∀ (a : γ), μ {x | a < f x} = ν {x | a < g x}
⊢ essSup f μ = essSup g ν
state_after: no goals
tactic: simp_rw [essSup_eq_sInf, I]
Theorem: Matroid.restrict_ground_eq_self
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
M : Matroid α
⊢ M ↾ M.E = M
state_after: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
M : Matroid α
⊢ ∀ I ⊆ (M ↾ M.E).E, (M ↾ M.E).Indep I ↔ M.Indep I
tactic: refine eq_of_indep_iff_indep_forall rfl ?_
state_before: α : Type u_1
M✝ : Matroid α
R I J X Y : Set α
M : Matroid α
⊢ ∀ I ⊆ (M ↾ M.E).E, (M ↾ M.E).Indep I ↔ M.Indep I
state_after: no goals
tactic: aesop
Theorem: Set.toFinset_univ
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝¹ : Fintype α
inst✝ : Fintype ↑univ
⊢ univ.toFinset = Finset.univ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝¹ : Fintype α
inst✝ : Fintype ↑univ
a✝ : α
⊢ a✝ ∈ univ.toFinset ↔ a✝ ∈ Finset.univ
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝¹ : Fintype α
inst✝ : Fintype ↑univ
a✝ : α
⊢ a✝ ∈ univ.toFinset ↔ a✝ ∈ Finset.univ
state_after: no goals
tactic: simp
Theorem: Units.exists_iff_ne_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b : G₀
p : G₀ → Prop
⊢ (∃ u, p ↑u) ↔ ∃ x, x ≠ 0 ∧ p x
state_after: no goals
tactic: simp [exists0]
Theorem: IsClosedMap.lift'_closure_map_eq
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
⊢ (map f F).lift' closure = map f (F.lift' closure)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
⊢ F.lift' (closure ∘ image f) = F.lift' (image f ∘ closure)
tactic: rw [map_lift'_eq2 (monotone_closure Y), map_lift'_eq (monotone_closure X)]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
⊢ F.lift' (closure ∘ image f) = F.lift' (image f ∘ closure)
state_after: case e_h
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
⊢ closure ∘ image f = image f ∘ closure
tactic: congr
state_before: case e_h
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
⊢ closure ∘ image f = image f ∘ closure
state_after: case e_h.h
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
s : Set X
⊢ (closure ∘ image f) s = (image f ∘ closure) s
tactic: ext s : 1
state_before: case e_h.h
X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f_closed : IsClosedMap f
f_cont : Continuous f
F : Filter X
s : Set X
⊢ (closure ∘ image f) s = (image f ∘ closure) s
state_after: no goals
tactic: exact f_closed.closure_image_eq_of_continuous f_cont s
Theorem: Finset.inl_mem_sumLift₂
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ inl c₁ ∈ sumLift₂ f g a b ↔ ∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f a₁ b₁
state_after: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ (∃ a₁ b₁ c₁_1, a = inl a₁ ∧ b = inl b₁ ∧ inl c₁ = inl c₁_1 ∧ c₁_1 ∈ f a₁ b₁) ↔
    ∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f a₁ b₁

α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ ¬∃ a₂ b₂ c₂, a = inr a₂ ∧ b = inr b₂ ∧ inl c₁ = inr c₂ ∧ c₂ ∈ g a₂ b₂
tactic: rw [mem_sumLift₂, or_iff_left]
state_before: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ ¬∃ a₂ b₂ c₂, a = inr a₂ ∧ b = inr b₂ ∧ inl c₁ = inr c₂ ∧ c₂ ∈ g a₂ b₂
state_after: case intro.intro.intro.intro.intro.intro
α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
w✝¹ : α₂
w✝ : β₂
c₂ : γ₂
left✝¹ : a = inr w✝¹
left✝ : b = inr w✝
h : inl c₁ = inr c₂
right✝ : c₂ ∈ g w✝¹ w✝
⊢ False
tactic: rintro ⟨_, _, c₂, _, _, h, _⟩
state_before: case intro.intro.intro.intro.intro.intro
α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f f₁ g₁ : α₁ → β₁ → Finset γ₁
g f₂ g₂ : α₂ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
w✝¹ : α₂
w✝ : β₂
c₂ : γ₂
left✝¹ : a = inr w✝¹
left✝ : b = inr w✝
h : inl c₁ = inr c₂
right✝ : c₂ ∈ g w✝¹ w✝
⊢ False
state_after: no goals
tactic: exact inl_ne_inr h