1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ordnode.Raised.right
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [node', size_node, size_node]
state_before: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
H : Raised r₁.size r₂.size
⊢ Raised (l.node' x₁ r₁).size (l.node' x₂ r₂).size
state_after: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
H : Raised r₁.size r₂.size
⊢ Raised (l.size + r₁.size + 1) (l.size + r₂.size + 1)

tactic: generalize size r₂ = m at H ⊢
state_before: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
H : Raised r₁.size r₂.size
⊢ Raised (l.size + r₁.size + 1) (l.size + r₂.size + 1)
state_after: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
m : ℕ
H : Raised r₁.size m
⊢ Raised (l.size + r₁.size + 1) (l.size + m + 1)

tactic: rcases H with (rfl | rfl)
state_before: α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
m : ℕ
H : Raised r₁.size m
⊢ Raised (l.size + r₁.size + 1) (l.size + m + 1)
state_after: case inl
α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
⊢ Raised (l.size + r₁.size + 1) (l.size + r₁.size + 1)

case inr
α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
⊢ Raised (l.size + r₁.size + 1) (l.size + (r₁.size + 1) + 1)

tactic: exact Or.inl rfl
state_before: case inl
α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
⊢ Raised (l.size + r₁.size + 1) (l.size + r₁.size + 1)
state_after: no goals

tactic: exact Or.inr rfl
state_before: case inr
α : Type u_1
l : Ordnode α
x₁ x₂ : α
r₁ r₂ : Ordnode α
⊢ Raised (l.size + r₁.size + 1) (l.size + (r₁.size + 1) + 1)
state_after: no goals
Theorem: norm_image_sub_le_of_norm_deriv_le_segment_01
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simpa only [sub_zero, mul_one] using
  norm_image_sub_le_of_norm_deriv_le_segment hf bound 1 (right_mem_Icc.2 zero_le_one)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc 0 1)
bound : ∀ x ∈ Ico 0 1, ‖derivWithin f (Icc 0 1) x‖ ≤ C
⊢ ‖f 1 - f 0‖ ≤ C
state_after: no goals
Theorem: sq_eq_one_iff
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [← (Commute.one_right a).sq_eq_sq_iff_eq_or_eq_neg, one_pow]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Ring R
a b : R
n : ℕ
inst✝ : NoZeroDivisors R
⊢ a ^ 2 = 1 ↔ a = 1 ∨ a = -1
state_after: no goals
Theorem: contDiff_succ_iff_fderiv_apply
File: Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean

tactic: rw [contDiff_succ_iff_fderiv, contDiff_clm_apply_iff]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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
inst✝¹ : CompleteSpace 𝕜
inst✝ : FiniteDimensional 𝕜 E
n : ℕ
f : E → F
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ∀ (y : E), ContDiff 𝕜 ↑n fun x => (fderiv 𝕜 f x) y
state_after: no goals
Theorem: Finset.sup_sdiff_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction s using Finset.cons_induction with
| empty => rw [sup_empty, sup_empty, bot_sdiff]
| cons _ _ _ h => rw [sup_cons, sup_cons, h, sup_sdiff]
state_before: F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝² : SemilatticeSup α✝
inst✝¹ : OrderBot α✝
s✝ s₁ s₂ : Finset β✝
f✝ g : β✝ → α✝
a✝ : α✝
α : Type u_7
β : Type u_8
inst✝ : GeneralizedBooleanAlgebra α
s : Finset β
f : β → α
a : α
⊢ (s.sup fun b => f b \ a) = s.sup f \ a
state_after: no goals

tactic: rw [sup_empty, sup_empty, bot_sdiff]
state_before: case empty
F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝² : SemilatticeSup α✝
inst✝¹ : OrderBot α✝
s s₁ s₂ : Finset β✝
f✝ g : β✝ → α✝
a✝ : α✝
α : Type u_7
β : Type u_8
inst✝ : GeneralizedBooleanAlgebra α
f : β → α
a : α
⊢ (∅.sup fun b => f b \ a) = ∅.sup f \ a
state_after: no goals

tactic: rw [sup_cons, sup_cons, h, sup_sdiff]
state_before: case cons
F : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝² : SemilatticeSup α✝
inst✝¹ : OrderBot α✝
s s₁ s₂ : Finset β✝
f✝ g : β✝ → α✝
a✝¹ : α✝
α : Type u_7
β : Type u_8
inst✝ : GeneralizedBooleanAlgebra α
f : β → α
a : α
a✝ : β
s✝ : Finset β
h✝ : a✝ ∉ s✝
h : (s✝.sup fun b => f b \ a) = s✝.sup f \ a
⊢ ((cons a✝ s✝ h✝).sup fun b => f b \ a) = (cons a✝ s✝ h✝).sup f \ a
state_after: no goals
Theorem: tprod_eq_mul_tprod_ite
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: rw [(hasProd_ite_div_hasProd hf.hasProd b).tprod_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommGroup α
inst✝³ : TopologicalSpace α
inst✝² : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝¹ : T2Space α
inst✝ : DecidableEq β
hf : Multipliable f
b : β
⊢ ∏' (n : β), f n = f b * ∏' (n : β), if n = b then 1 else f n
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommGroup α
inst✝³ : TopologicalSpace α
inst✝² : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝¹ : T2Space α
inst✝ : DecidableEq β
hf : Multipliable f
b : β
⊢ ∏' (n : β), f n = f b * ((∏' (b : β), f b) / f b)

tactic: exact (mul_div_cancel _ _).symm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommGroup α
inst✝³ : TopologicalSpace α
inst✝² : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
inst✝¹ : T2Space α
inst✝ : DecidableEq β
hf : Multipliable f
b : β
⊢ ∏' (n : β), f n = f b * ((∏' (b : β), f b) / f b)
state_after: no goals
Theorem: ZMod.ne_zero_iff_odd
File: Mathlib/Data/ZMod/Parity.lean

tactic: contrapose
state_before: case mpr
n : ℕ
⊢ Odd n → ↑n ≠ 0
state_after: case mpr
n : ℕ
⊢ ¬↑n ≠ 0 → ¬Odd n

tactic: simp [eq_zero_iff_even]
state_before: case mpr
n : ℕ
⊢ ¬↑n ≠ 0 → ¬Odd n
state_after: no goals
Theorem: ideal_eq_bot_of_localization
File: Mathlib/RingTheory/LocalProperties.lean

tactic: rw [RingHom.mem_ker, ← Submodule.mem_bot R, ← h P hP, IsLocalization.mem_coeSubmodule]
state_before: R S : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
M : Submonoid R
N : Submonoid S
R' S' : Type u
inst✝³ : CommRing R'
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R R'
inst✝ : Algebra S S'
I : Ideal R
h : ∀ (J : Ideal R) (hJ : J.IsMaximal), IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥
P : Ideal R
hP : P.IsMaximal
x : R
hx : x ∈ I
⊢ x ∈ RingHom.ker (algebraMap R (Localization.AtPrime P))
state_after: R S : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
M : Submonoid R
N : Submonoid S
R' S' : Type u
inst✝³ : CommRing R'
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R R'
inst✝ : Algebra S S'
I : Ideal R
h : ∀ (J : Ideal R) (hJ : J.IsMaximal), IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥
P : Ideal R
hP : P.IsMaximal
x : R
hx : x ∈ I
⊢ ∃ y ∈ I, (algebraMap R (Localization.AtPrime P)) y = (algebraMap R (Localization.AtPrime P)) x

tactic: exact ⟨x, hx, rfl⟩
state_before: R S : Type u
inst✝⁵ : CommRing R
inst✝⁴ : CommRing S
M : Submonoid R
N : Submonoid S
R' S' : Type u
inst✝³ : CommRing R'
inst✝² : CommRing S'
f : R →+* S
inst✝¹ : Algebra R R'
inst✝ : Algebra S S'
I : Ideal R
h : ∀ (J : Ideal R) (hJ : J.IsMaximal), IsLocalization.coeSubmodule (Localization.AtPrime J) I = ⊥
P : Ideal R
hP : P.IsMaximal
x : R
hx : x ∈ I
⊢ ∃ y ∈ I, (algebraMap R (Localization.AtPrime P)) y = (algebraMap R (Localization.AtPrime P)) x
state_after: no goals
Theorem: Nat.ofDigits_modEq'
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with d L ih
state_before: n b b' k : ℕ
h : b ≡ b' [MOD k]
L : List ℕ
⊢ ofDigits b L ≡ ofDigits b' L [MOD k]
state_after: case nil
n b b' k : ℕ
h : b ≡ b' [MOD k]
⊢ ofDigits b [] ≡ ofDigits b' [] [MOD k]

case cons
n b b' k : ℕ
h : b ≡ b' [MOD k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [MOD k]
⊢ ofDigits b (d :: L) ≡ ofDigits b' (d :: L) [MOD k]

tactic: rfl
state_before: case nil
n b b' k : ℕ
h : b ≡ b' [MOD k]
⊢ ofDigits b [] ≡ ofDigits b' [] [MOD k]
state_after: no goals

tactic: dsimp [ofDigits]
state_before: case cons
n b b' k : ℕ
h : b ≡ b' [MOD k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [MOD k]
⊢ ofDigits b (d :: L) ≡ ofDigits b' (d :: L) [MOD k]
state_after: case cons
n b b' k : ℕ
h : b ≡ b' [MOD k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [MOD k]
⊢ d + b * ofDigits b L ≡ d + b' * ofDigits b' L [MOD k]

tactic: dsimp [Nat.ModEq] at *
state_before: case cons
n b b' k : ℕ
h : b ≡ b' [MOD k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [MOD k]
⊢ d + b * ofDigits b L ≡ d + b' * ofDigits b' L [MOD k]
state_after: case cons
n b b' k : ℕ
h : b % k = b' % k
d : ℕ
L : List ℕ
ih : ofDigits b L % k = ofDigits b' L % k
⊢ (d + b * ofDigits b L) % k = (d + b' * ofDigits b' L) % k

tactic: conv_lhs => rw [Nat.add_mod, Nat.mul_mod, h, ih]
state_before: case cons
n b b' k : ℕ
h : b % k = b' % k
d : ℕ
L : List ℕ
ih : ofDigits b L % k = ofDigits b' L % k
⊢ (d + b * ofDigits b L) % k = (d + b' * ofDigits b' L) % k
state_after: case cons
n b b' k : ℕ
h : b % k = b' % k
d : ℕ
L : List ℕ
ih : ofDigits b L % k = ofDigits b' L % k
⊢ (d % k + b' % k * (ofDigits b' L % k) % k) % k = (d + b' * ofDigits b' L) % k

tactic: conv_rhs => rw [Nat.add_mod, Nat.mul_mod]
state_before: case cons
n b b' k : ℕ
h : b % k = b' % k
d : ℕ
L : List ℕ
ih : ofDigits b L % k = ofDigits b' L % k
⊢ (d % k + b' % k * (ofDigits b' L % k) % k) % k = (d + b' * ofDigits b' L) % k
state_after: no goals
Theorem: toIocMod_neg'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [neg_neg] using toIocMod_neg hp (-a) (-b)
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (-a) b = p - toIcoMod hp a (-b)
state_after: no goals
Theorem: NormedRing.inverse_one_sub
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: rw [← inverse_unit (Units.oneSub t h), Units.val_oneSub]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
t : R
h : ‖t‖ < 1
⊢ inverse (1 - t) = ↑(Units.oneSub t h)⁻¹
state_after: no goals
Theorem: spectrum.map_star
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: ext
state_before: R : Type u
A : Type v
inst✝⁵ : CommSemiring R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : InvolutiveStar R
inst✝¹ : StarRing A
inst✝ : StarModule R A
a : A
⊢ σ (star a) = star (σ a)
state_after: case h
R : Type u
A : Type v
inst✝⁵ : CommSemiring R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : InvolutiveStar R
inst✝¹ : StarRing A
inst✝ : StarModule R A
a : A
x✝ : R
⊢ x✝ ∈ σ (star a) ↔ x✝ ∈ star (σ a)

tactic: simpa only [Set.mem_star, mem_iff, not_iff_not] using star_mem_resolventSet_iff.symm
state_before: case h
R : Type u
A : Type v
inst✝⁵ : CommSemiring R
inst✝⁴ : Ring A
inst✝³ : Algebra R A
inst✝² : InvolutiveStar R
inst✝¹ : StarRing A
inst✝ : StarModule R A
a : A
x✝ : R
⊢ x✝ ∈ σ (star a) ↔ x✝ ∈ star (σ a)
state_after: no goals
Theorem: Matrix.exp_transpose
File: Mathlib/Analysis/NormedSpace/MatrixExponential.lean

tactic: simp_rw [exp_eq_tsum, transpose_tsum, transpose_smul, transpose_pow]
state_before: 𝕂 : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
n' : m → Type u_5
𝔸 : Type u_6
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq m
inst✝⁵ : Field 𝕂
inst✝⁴ : CommRing 𝔸
inst✝³ : TopologicalSpace 𝔸
inst✝² : TopologicalRing 𝔸
inst✝¹ : Algebra 𝕂 𝔸
inst✝ : T2Space 𝔸
A : Matrix m m 𝔸
⊢ exp 𝕂 Aᵀ = (exp 𝕂 A)ᵀ
state_after: no goals
Theorem: Int.floor_nonneg
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [le_floor, Int.cast_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ 0 ≤ ⌊a⌋ ↔ 0 ≤ a
state_after: no goals
Theorem: Submodule.map_inl
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext ⟨x, y⟩
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (inl R M M₂) p = p.prod ⊥
state_after: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ map (inl R M M₂) p ↔ (x, y) ∈ p.prod ⊥

tactic: simp only [and_left_comm, eq_comm, mem_map, Prod.mk.inj_iff, inl_apply, mem_bot, exists_eq_left',
  mem_prod]
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ map (inl R M M₂) p ↔ (x, y) ∈ p.prod ⊥
state_after: no goals
Theorem: eq_iff_eq_cancel_left
File: Mathlib/Logic/Basic.lean

tactic: rw [← h]
state_before: α : Sort u_1
b c : α
h : ∀ {a : α}, a = b ↔ a = c
⊢ b = c
state_after: no goals

tactic: rw [h]
state_before: α : Sort u_1
b c : α
h : b = c
a : α
⊢ a = b ↔ a = c
state_after: no goals
Theorem: Filter.IsBoundedUnder.bddAbove_range
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [← Nat.cofinite_eq_atTop] at hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) atTop f
⊢ BddAbove (range f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) cofinite f
⊢ BddAbove (range f)

tactic: exact hf.bddAbove_range_of_cofinite
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f✝ g : Filter α
inst✝¹ : Preorder β
inst✝ : IsDirected β fun x x_1 => x ≤ x_1
f : ℕ → β
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) cofinite f
⊢ BddAbove (range f)
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.range_const
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp (config := { unfoldPartialApp := true }) [Function.const]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α✝
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : Nonempty α
b : β
⊢ ↑(const α b).range = ↑{b}
state_after: no goals
Theorem: CategoryTheory.shiftFunctorAdd'_add_zero_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: simpa using NatTrans.congr_app (congr_arg Iso.inv (shiftFunctorAdd'_add_zero C a)) X
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctorAdd' C a 0 a ⋯).inv.app X = (shiftFunctorZero C A).hom.app ((shiftFunctor C a).obj X)
state_after: no goals
Theorem: MeasureTheory.Measure.map_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [← measure_univ_eq_zero, map_apply_of_aemeasurable hf .univ, preimage_univ]
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 : α → β
hf : AEMeasurable f μ
⊢ map f μ = 0 ↔ μ = 0
state_after: no goals
Theorem: Polynomial.natDegree_eq_zero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: aesop
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
p : R[X]
⊢ (∃ x, C x = p) → p.natDegree = 0
state_after: no goals
Theorem: Cardinal.mk_list_le_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: cases finite_or_infinite α
state_before: α : Type u
⊢ #(List α) ≤ max ℵ₀ #α
state_after: case inl
α : Type u
h✝ : Finite α
⊢ #(List α) ≤ max ℵ₀ #α

case inr
α : Type u
h✝ : Infinite α
⊢ #(List α) ≤ max ℵ₀ #α

tactic: exact mk_le_aleph0.trans (le_max_left _ _)
state_before: case inl
α : Type u
h✝ : Finite α
⊢ #(List α) ≤ max ℵ₀ #α
state_after: no goals

tactic: rw [mk_list_eq_mk]
state_before: case inr
α : Type u
h✝ : Infinite α
⊢ #(List α) ≤ max ℵ₀ #α
state_after: case inr
α : Type u
h✝ : Infinite α
⊢ #α ≤ max ℵ₀ #α

tactic: apply le_max_right
state_before: case inr
α : Type u
h✝ : Infinite α
⊢ #α ≤ max ℵ₀ #α
state_after: no goals
Theorem: List.alternatingProd_eq_finset_prod
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [alternatingProd, Finset.prod_eq_one]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
⊢ [].alternatingProd = ∏ i : Fin [].length, [].get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
⊢ ∀ x ∈ univ, [].get x ^ (-1) ^ ↑x = 1

tactic: rintro ⟨i, ⟨⟩⟩
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
⊢ ∀ x ∈ univ, [].get x ^ (-1) ^ ↑x = 1
state_after: no goals

tactic: show g = ∏ i : Fin 1, [g].get i ^ (-1 : ℤ) ^ (i : ℕ)
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ [g].alternatingProd = ∏ i : Fin [g].length, [g].get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = ∏ i : Fin 1, [g].get i ^ (-1) ^ ↑i

tactic: rw [Fin.prod_univ_succ]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = ∏ i : Fin 1, [g].get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = [g].get 0 ^ (-1) ^ ↑0 * ∏ i : Fin 0, [g].get i.succ ^ (-1) ^ ↑i.succ

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = [g].get 0 ^ (-1) ^ ↑0 * ∏ i : Fin 0, [g].get i.succ ^ (-1) ^ ↑i.succ
state_after: no goals

tactic: rw [Fin.prod_univ_succ, Fin.prod_univ_succ, mul_assoc]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g h : G
L : List G
⊢ g * h⁻¹ * ∏ i : Fin L.length, L.get i ^ (-1) ^ ↑i = ∏ i : Fin (L.length + 2), (g :: h :: L).get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g h : G
L : List G
⊢ g * (h⁻¹ * ∏ i : Fin L.length, L.get i ^ (-1) ^ ↑i) =
    (g :: h :: L).get 0 ^ (-1) ^ ↑0 *
      ((g :: h :: L).get (Fin.succ 0) ^ (-1) ^ ↑(Fin.succ 0) *
        ∏ i : Fin L.length, (g :: h :: L).get i.succ.succ ^ (-1) ^ ↑i.succ.succ)

tactic: simp [pow_add]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g h : G
L : List G
⊢ g * (h⁻¹ * ∏ i : Fin L.length, L.get i ^ (-1) ^ ↑i) =
    (g :: h :: L).get 0 ^ (-1) ^ ↑0 *
      ((g :: h :: L).get (Fin.succ 0) ^ (-1) ^ ↑(Fin.succ 0) *
        ∏ i : Fin L.length, (g :: h :: L).get i.succ.succ ^ (-1) ^ ↑i.succ.succ)
state_after: no goals
Theorem: DFinsupp.support_update_ne_zero
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext j
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)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
⊢ (update i f b).support = insert i f.support
state_after: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
j : ι
⊢ j ∈ (update i f b).support ↔ j ∈ insert i f.support

tactic: rcases eq_or_ne i j with (rfl | hi)
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
j : ι
⊢ j ∈ (update i f b).support ↔ j ∈ insert i f.support
state_after: case a.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
⊢ i ∈ (update i f b).support ↔ i ∈ insert i f.support

case a.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
j : ι
hi : i ≠ j
⊢ j ∈ (update i f b).support ↔ j ∈ insert i f.support

tactic: simp [h]
state_before: case a.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
⊢ i ∈ (update i f b).support ↔ i ∈ insert i f.support
state_after: no goals

tactic: simp [hi.symm]
state_before: case a.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
j : ι
hi : i ≠ j
⊢ j ∈ (update i f b).support ↔ j ∈ insert i f.support
state_after: no goals
Theorem: abs_sub
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [sub_eq_add_neg, ← abs_neg b]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ |a - b| ≤ |a| + |b|
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ |a + -b| ≤ |a| + |(-b)|

tactic: exact abs_add a _
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ |a + -b| ≤ |a| + |(-b)|
state_after: no goals
Theorem: DilationEquiv.smulTorsor_preimage_ball
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: aesop (add simp norm_smul)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁵ : NormedDivisionRing 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : BoundedSMul 𝕜 E
P : Type u_3
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
k : 𝕜
hk : k ≠ 0
⊢ ⇑(smulTorsor c hk) ⁻¹' Metric.ball c ‖k‖ = Metric.ball 0 1
state_after: no goals
Theorem: MvPolynomial.map_bind₂
File: Mathlib/Algebra/MvPolynomial/Monad.lean

tactic: simp only [bind₂, eval₂_comp_right, coe_eval₂Hom, eval₂_map]
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
⊢ (map g) ((bind₂ f) φ) = (bind₂ ((map g).comp f)) φ
state_after: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
⊢ eval₂ ((map g).comp f) (⇑(map g) ∘ X) φ = eval₂ ((map g).comp f) X φ

tactic: congr 1 with : 1
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
⊢ eval₂ ((map g).comp f) (⇑(map g) ∘ X) φ = eval₂ ((map g).comp f) X φ
state_after: case e_g.h
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
x✝ : σ
⊢ (⇑(map g) ∘ X) x✝ = X x✝

tactic: simp only [Function.comp_apply, map_X]
state_before: case e_g.h
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* T
φ : MvPolynomial σ R
x✝ : σ
⊢ (⇑(map g) ∘ X) x✝ = X x✝
state_after: no goals
Theorem: edist_eq_coe_nnnorm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [edist_eq_coe_nnnorm_div, div_one]
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₂ : ℝ
inst✝ : FunLike 𝓕 E F
x : E
⊢ edist x 1 = ↑‖x‖₊
state_after: no goals