1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: PadicInt.zmod_congr_of_sub_mem_max_ideal
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: rw [maximalIdeal_eq_span_p] at hm hn
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ maximalIdeal ℤ_[p]
hn : x - ↑n ∈ maximalIdeal ℤ_[p]
⊢ ↑m = ↑n
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
⊢ ↑m = ↑n

tactic: have := zmod_congr_of_sub_mem_span_aux 1 x m n
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
⊢ ↑m = ↑n
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : x - ↑↑m ∈ Ideal.span {↑p ^ 1} → x - ↑↑n ∈ Ideal.span {↑p ^ 1} → ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: simp only [pow_one] at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : x - ↑↑m ∈ Ideal.span {↑p ^ 1} → x - ↑↑n ∈ Ideal.span {↑p ^ 1} → ↑↑m = ↑↑n
⊢ ↑m = ↑n
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : x - ↑↑m ∈ Ideal.span {↑p} → x - ↑↑n ∈ Ideal.span {↑p} → ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: specialize this hm hn
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : x - ↑↑m ∈ Ideal.span {↑p} → x - ↑↑n ∈ Ideal.span {↑p} → ↑↑m = ↑↑n
⊢ ↑m = ↑n
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: apply_fun ZMod.castHom (show p ∣ p ^ 1 by rw [pow_one]) (ZMod p) at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ ↑m = ↑n
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : (ZMod.castHom ⋯ (ZMod p)) ↑↑m = (ZMod.castHom ⋯ (ZMod p)) ↑↑n
⊢ ↑m = ↑n

tactic: simp only [map_intCast] at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : (ZMod.castHom ⋯ (ZMod p)) ↑↑m = (ZMod.castHom ⋯ (ZMod p)) ↑↑n
⊢ ↑m = ↑n
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: simpa only [Int.cast_natCast] using this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ ↑m = ↑n
state_after: no goals

tactic: rw [pow_one]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ p ∣ p ^ 1
state_after: no goals
Theorem: Function.Periodic.sub_antiperiod
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg] using h1.add_antiperiod h2.neg
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h1 : Periodic f c₁
h2 : Antiperiodic f c₂
⊢ Antiperiodic f (c₁ - c₂)
state_after: no goals
Theorem: ProbabilityTheory.kernel.const_zero
File: Mathlib/Probability/Kernel/Basic.lean

tactic: ext x s _
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α β)
⊢ const α 0 = 0
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α β)
x : α
s : Set β
a✝ : MeasurableSet s
⊢ ((const α 0) x) s = (0 x) s

tactic: simp [kernel.const_apply]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α β)
x : α
s : Set β
a✝ : MeasurableSet s
⊢ ((const α 0) x) s = (0 x) s
state_after: no goals
Theorem: AddMonoidHom.apply_nat
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: rw [← multiplesHom_symm_apply, ← multiplesHom_apply, Equiv.apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Monoid α
inst✝ : AddMonoid α
f : ℕ →+ α
n : ℕ
⊢ f n = n • f 1
state_after: no goals
Theorem: RightDerivMeasurableAux.A_mono
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

tactic: rintro x ⟨r', r'r, hr'⟩
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
⊢ A f L r ε ⊆ A f L r δ
state_after: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x ∈ A f L r δ

tactic: refine ⟨r', r'r, fun y hy z hz => (hr' y hy z hz).trans (mul_le_mul_of_nonneg_right h ?_)⟩
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x ∈ A f L r δ
state_after: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
y : ℝ
hy : y ∈ Icc x (x + r')
z : ℝ
hz : z ∈ Icc x (x + r')
⊢ 0 ≤ r

tactic: linarith [hy.1, hy.2, r'r.2]
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ y ∈ Icc x (x + r'), ∀ z ∈ Icc x (x + r'), ‖f z - f y - (z - y) • L‖ ≤ ε * r
y : ℝ
hy : y ∈ Icc x (x + r')
z : ℝ
hz : z ∈ Icc x (x + r')
⊢ 0 ≤ r
state_after: no goals
Theorem: PowerSeries.map_exp
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: ext
state_before: A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ (map f) (exp A) = exp A'
state_after: case h
A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
n✝ : ℕ
⊢ (coeff A' n✝) ((map f) (exp A)) = (coeff A' n✝) (exp A')

tactic: simp
state_before: case h
A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
n✝ : ℕ
⊢ (coeff A' n✝) ((map f) (exp A)) = (coeff A' n✝) (exp A')
state_after: no goals
Theorem: Real.volume_Icc_pi_toReal
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [volume_Icc_pi, ENNReal.toReal_prod, ENNReal.toReal_ofReal (sub_nonneg.2 (h _))]
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ι → ℝ
h : a ≤ b
⊢ (volume (Icc a b)).toReal = ∏ i : ι, (b i - a i)
state_after: no goals
Theorem: PMF.bind_pure
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: rw [pure_apply_of_ne _ _ hy.symm, mul_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
x y : α
hy : y ≠ x
⊢ p y * (pure y) x = 0
state_after: no goals

tactic: rw [pure_apply_self, mul_one]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : α → PMF β
g : β → PMF γ
x : α
⊢ p x * (pure x) x = p x
state_after: no goals
Theorem: AddMonoidAlgebra.finiteType_iff_group_fg
File: Mathlib/RingTheory/FiniteType.lean

tactic: simpa [AddGroup.fg_iff_addMonoid_fg] using finiteType_iff_fg
state_before: R : Type u_1
M : Type u_2
inst✝³ : AddMonoid M
G : Type u_3
inst✝² : AddCommGroup G
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ FiniteType R R[G] ↔ AddGroup.FG G
state_after: no goals
Theorem: Real.Gamma_add_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: simp_rw [Gamma]
state_before: s : ℝ
hs : s ≠ 0
⊢ Gamma (s + 1) = s * Gamma s
state_after: s : ℝ
hs : s ≠ 0
⊢ (Complex.Gamma ↑(s + 1)).re = s * (Complex.Gamma ↑s).re

tactic: rw [Complex.ofReal_add, Complex.ofReal_one, Complex.Gamma_add_one, Complex.re_ofReal_mul]
state_before: s : ℝ
hs : s ≠ 0
⊢ (Complex.Gamma ↑(s + 1)).re = s * (Complex.Gamma ↑s).re
state_after: case h2
s : ℝ
hs : s ≠ 0
⊢ ↑s ≠ 0

tactic: rwa [Complex.ofReal_ne_zero]
state_before: case h2
s : ℝ
hs : s ≠ 0
⊢ ↑s ≠ 0
state_after: no goals
Theorem: Orientation.oangle_sub_eq_oangle_sub_rev_of_norm_eq
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: simp [oangle, h]
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : ‖x‖ = ‖y‖
⊢ o.oangle x (x - y) = o.oangle (y - x) y
state_after: no goals
Theorem: List.Perm.erase
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: have h₂ : a ∉ l₂ := mt p.mem_iff.2 h₁
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
⊢ l₁.erase a ~ l₂.erase a
state_after: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁.erase a ~ l₂.erase a

tactic: rw [erase_of_not_mem h₁, erase_of_not_mem h₂]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁.erase a ~ l₂.erase a
state_after: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁ ~ l₂

tactic: exact p
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l₁ l₂ : List α
p : l₁ ~ l₂
h₁ : ¬a ∈ l₁
h₂ : ¬a ∈ l₂
⊢ l₁ ~ l₂
state_after: no goals
Theorem: Commute.inv_mul_cancel_assoc
File: Mathlib/Algebra/Group/Commute/Basic.lean

tactic: rw [← mul_assoc, h.inv_mul_cancel]
state_before: G : Type u_1
inst✝ : Group G
a b : G
h : Commute a b
⊢ a⁻¹ * (b * a) = b
state_after: no goals
Theorem: Algebra.Generators.Hom.id_comp
File: Mathlib/RingTheory/Generators.lean

tactic: ext
state_before: R : Type u
S : Type v
inst✝²⁵ : CommRing R
inst✝²⁴ : CommRing S
inst✝²³ : Algebra R S
P : Generators R S
R' : Type u_1
S' : Type u_2
inst✝²² : CommRing R'
inst✝²¹ : CommRing S'
inst✝²⁰ : Algebra R' S'
P' : Generators R' S'
inst✝¹⁹ : Algebra R R'
inst✝¹⁸ : Algebra S S'
inst✝¹⁷ : Algebra R S'
inst✝¹⁶ : IsScalarTower R R' S'
inst✝¹⁵ : IsScalarTower R S S'
R'' : Type ?u.338019
S'' : Type ?u.338022
inst✝¹⁴ : CommRing R''
inst✝¹³ : CommRing S''
inst✝¹² : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹¹ : Algebra R R''
inst✝¹⁰ : Algebra S S''
inst✝⁹ : Algebra R S''
inst✝⁸ : IsScalarTower R R'' S''
inst✝⁷ : IsScalarTower R S S''
inst✝⁶ : Algebra R' R''
inst✝⁵ : Algebra S' S''
inst✝⁴ : Algebra R' S''
inst✝³ : IsScalarTower R' R'' S''
inst✝² : IsScalarTower R' S' S''
inst✝¹ : IsScalarTower R' R'' R''
inst✝ : IsScalarTower S S' S''
f : P.Hom P'
⊢ (Hom.id P').comp f = f
state_after: case val.h.a
R : Type u
S : Type v
inst✝²⁵ : CommRing R
inst✝²⁴ : CommRing S
inst✝²³ : Algebra R S
P : Generators R S
R' : Type u_1
S' : Type u_2
inst✝²² : CommRing R'
inst✝²¹ : CommRing S'
inst✝²⁰ : Algebra R' S'
P' : Generators R' S'
inst✝¹⁹ : Algebra R R'
inst✝¹⁸ : Algebra S S'
inst✝¹⁷ : Algebra R S'
inst✝¹⁶ : IsScalarTower R R' S'
inst✝¹⁵ : IsScalarTower R S S'
R'' : Type ?u.338019
S'' : Type ?u.338022
inst✝¹⁴ : CommRing R''
inst✝¹³ : CommRing S''
inst✝¹² : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹¹ : Algebra R R''
inst✝¹⁰ : Algebra S S''
inst✝⁹ : Algebra R S''
inst✝⁸ : IsScalarTower R R'' S''
inst✝⁷ : IsScalarTower R S S''
inst✝⁶ : Algebra R' R''
inst✝⁵ : Algebra S' S''
inst✝⁴ : Algebra R' S''
inst✝³ : IsScalarTower R' R'' S''
inst✝² : IsScalarTower R' S' S''
inst✝¹ : IsScalarTower R' R'' R''
inst✝ : IsScalarTower S S' S''
f : P.Hom P'
x✝ : P.vars
m✝ : P'.vars →₀ ℕ
⊢ coeff m✝ (((Hom.id P').comp f).val x✝) = coeff m✝ (f.val x✝)

tactic: simp [Hom.id, aeval_X_left]
state_before: case val.h.a
R : Type u
S : Type v
inst✝²⁵ : CommRing R
inst✝²⁴ : CommRing S
inst✝²³ : Algebra R S
P : Generators R S
R' : Type u_1
S' : Type u_2
inst✝²² : CommRing R'
inst✝²¹ : CommRing S'
inst✝²⁰ : Algebra R' S'
P' : Generators R' S'
inst✝¹⁹ : Algebra R R'
inst✝¹⁸ : Algebra S S'
inst✝¹⁷ : Algebra R S'
inst✝¹⁶ : IsScalarTower R R' S'
inst✝¹⁵ : IsScalarTower R S S'
R'' : Type ?u.338019
S'' : Type ?u.338022
inst✝¹⁴ : CommRing R''
inst✝¹³ : CommRing S''
inst✝¹² : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹¹ : Algebra R R''
inst✝¹⁰ : Algebra S S''
inst✝⁹ : Algebra R S''
inst✝⁸ : IsScalarTower R R'' S''
inst✝⁷ : IsScalarTower R S S''
inst✝⁶ : Algebra R' R''
inst✝⁵ : Algebra S' S''
inst✝⁴ : Algebra R' S''
inst✝³ : IsScalarTower R' R'' S''
inst✝² : IsScalarTower R' S' S''
inst✝¹ : IsScalarTower R' R'' R''
inst✝ : IsScalarTower S S' S''
f : P.Hom P'
x✝ : P.vars
m✝ : P'.vars →₀ ℕ
⊢ coeff m✝ (((Hom.id P').comp f).val x✝) = coeff m✝ (f.val x✝)
state_after: no goals
Theorem: ModularGroup.coe_T_inv
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simp [coe_inv, coe_T, adjugate_fin_two]
state_before: ⊢ ↑T⁻¹ = of ![![1, -1], ![0, 1]]
state_after: no goals
Theorem: List.replaceF_of_forall_none
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction l with
| nil => rfl
| cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2]
state_before: α : Type u_1
p : α → Option α
l : List α
h : ∀ (a : α), a ∈ l → p a = none
⊢ replaceF p l = l
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
p : α → Option α
h : ∀ (a : α), a ∈ [] → p a = none
⊢ replaceF p [] = []
state_after: no goals

tactic: simp [h _ (.head ..), ih (forall_mem_cons.1 h).2]
state_before: case cons
α : Type u_1
p : α → Option α
head✝ : α
tail✝ : List α
ih : (∀ (a : α), a ∈ tail✝ → p a = none) → replaceF p tail✝ = tail✝
h : ∀ (a : α), a ∈ head✝ :: tail✝ → p a = none
⊢ replaceF p (head✝ :: tail✝) = head✝ :: tail✝
state_after: no goals
Theorem: List.getElem?_set_eq_of_lt
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [getElem?_set_eq', getElem?_eq_getElem h]
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (l.set n a)[n]? = some a
state_after: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (fun x => a) <$> some l[n] = some a

tactic: rfl
state_before: α : Type u_1
a : α
n : Nat
l : List α
h : n < l.length
⊢ (fun x => a) <$> some l[n] = some a
state_after: no goals
Theorem: ArithmeticFunction.vonMangoldt_le_log
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: simp
state_before: ⊢ Λ 0 ≤ Real.log ↑0
state_after: no goals

tactic: rw [← vonMangoldt_sum]
state_before: n : ℕ
⊢ Λ (n + 1) ≤ Real.log ↑(n + 1)
state_after: n : ℕ
⊢ Λ (n + 1) ≤ ∑ i ∈ (n + 1).divisors, Λ i

tactic: exact single_le_sum (by exact fun _ _ => vonMangoldt_nonneg)
  (mem_divisors_self _ n.succ_ne_zero)
state_before: n : ℕ
⊢ Λ (n + 1) ≤ ∑ i ∈ (n + 1).divisors, Λ i
state_after: no goals

tactic: exact fun _ _ => vonMangoldt_nonneg
state_before: n : ℕ
⊢ ∀ i ∈ (n + 1).divisors, 0 ≤ Λ i
state_after: no goals
Theorem: Associates.mem_factorSet_top
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: dsimp only [Membership.mem]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ p ∈ ⊤
state_after: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ p.FactorSetMem ⊤

tactic: dsimp only [FactorSetMem]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ p.FactorSetMem ⊤
state_after: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ if hp : Irreducible p then BfactorSetMem ⟨p, hp⟩ ⊤ else False

tactic: split_ifs
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ if hp : Irreducible p then BfactorSetMem ⟨p, hp⟩ ⊤ else False
state_after: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ BfactorSetMem ⟨p, hp⟩ ⊤

tactic: exact trivial
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : Irreducible p
⊢ BfactorSetMem ⟨p, hp⟩ ⊤
state_after: no goals
Theorem: DFinsupp.equivFunOnFintype_symm_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext i'
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
⊢ equivFunOnFintype.symm (Pi.single i m) = single i m
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
i' : ι
⊢ (equivFunOnFintype.symm (Pi.single i m)) i' = (single i m) i'

tactic: simp only [← single_eq_pi_single, equivFunOnFintype_symm_coe]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝ : Fintype ι
i : ι
m : β i
i' : ι
⊢ (equivFunOnFintype.symm (Pi.single i m)) i' = (single i m) i'
state_after: no goals
Theorem: LieModule.isNilpotent_range_toEnd_iff
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: constructor <;> rintro ⟨k, hk⟩ <;> use k <;>
    rw [← LieSubmodule.coe_toSubmodule_eq_iff] at hk ⊢ <;>
  simpa using hk
state_before: R : Type u
L : Type v
M : Type w
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
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
⊢ IsNilpotent R (↥(toEnd R L M).range) M ↔ IsNilpotent R L M
state_after: no goals
Theorem: Real.Gamma_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: simpa only [← Complex.ofReal_zero, Complex.Gamma_ofReal, Complex.ofReal_inj] using
  Complex.Gamma_zero
state_before: ⊢ Gamma 0 = 0
state_after: no goals
Theorem: CategoryTheory.Presieve.le_of_factorsThru_sieve
File: Mathlib/CategoryTheory/Sites/Coverage.lean

tactic: rintro Y f hf
state_before: C : Type u_2
D : Type ?u.23133
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.23141, ?u.23133} D
X : C
S : Presieve X
T : Sieve X
h : S.FactorsThru T.arrows
⊢ S ≤ T.arrows
state_after: C : Type u_2
D : Type ?u.23133
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.23141, ?u.23133} D
X : C
S : Presieve X
T : Sieve X
h : S.FactorsThru T.arrows
Y : C
f : Y ⟶ X
hf : f ∈ S
⊢ f ∈ T.arrows

tactic: obtain ⟨W, i, e, h1, rfl⟩ := h hf
state_before: C : Type u_2
D : Type ?u.23133
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.23141, ?u.23133} D
X : C
S : Presieve X
T : Sieve X
h : S.FactorsThru T.arrows
Y : C
f : Y ⟶ X
hf : f ∈ S
⊢ f ∈ T.arrows
state_after: case intro.intro.intro.intro
C : Type u_2
D : Type ?u.23133
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.23141, ?u.23133} D
X : C
S : Presieve X
T : Sieve X
h : S.FactorsThru T.arrows
Y W : C
i : Y ⟶ W
e : W ⟶ X
h1 : T.arrows e
hf : i ≫ e ∈ S
⊢ i ≫ e ∈ T.arrows

tactic: exact T.downward_closed h1 _
state_before: case intro.intro.intro.intro
C : Type u_2
D : Type ?u.23133
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.23141, ?u.23133} D
X : C
S : Presieve X
T : Sieve X
h : S.FactorsThru T.arrows
Y W : C
i : Y ⟶ W
e : W ⟶ X
h1 : T.arrows e
hf : i ≫ e ∈ S
⊢ i ≫ e ∈ T.arrows
state_after: no goals
Theorem: Cardinal.isRegular_aleph0
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simp
state_before: α : Type u_1
r : α → α → Prop
⊢ ℵ₀ ≤ ℵ₀.ord.cof
state_after: no goals
Theorem: Stream'.WSeq.head_nil
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [head]
state_before: α : Type u
β : Type v
γ : Type w
⊢ nil.head = Computation.pure none
state_after: no goals
Theorem: Set.bounded_inter_not
File: Mathlib/Order/Bounded.lean

tactic: refine ⟨?_, Bounded.mono inter_subset_left⟩
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a : α
⊢ Bounded r (s ∩ {b | ¬r b a}) ↔ Bounded r s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a : α
⊢ Bounded r (s ∩ {b | ¬r b a}) → Bounded r s

tactic: rintro ⟨b, hb⟩
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a : α
⊢ Bounded r (s ∩ {b | ¬r b a}) → Bounded r s
state_after: case intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
⊢ Bounded r s

tactic: cases' H a b with m hm
state_before: case intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
⊢ Bounded r s
state_after: case intro.intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
m : α
hm : ∀ (c : α), r c a ∨ r c b → r c m
⊢ Bounded r s

tactic: exact ⟨m, fun c hc => hm c (or_iff_not_imp_left.2 fun hca => hb c ⟨hc, hca⟩)⟩
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
s t : Set α
H : ∀ (a b : α), ∃ m, ∀ (c : α), r c a ∨ r c b → r c m
a b : α
hb : ∀ b_1 ∈ s ∩ {b | ¬r b a}, r b_1 b
m : α
hm : ∀ (c : α), r c a ∨ r c b → r c m
⊢ Bounded r s
state_after: no goals
Theorem: CliffordAlgebra.contractRight_algebraMap
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: rw [contractRight_eq, reverse.commutes, contractLeft_algebraMap, map_zero]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
⊢ (contractRight ((algebraMap R (CliffordAlgebra Q)) r)) d = 0
state_after: no goals
Theorem: Vector.mapAccumr_mapAccumr₂
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
state_before: α : Type
n : ℕ
β : Type
xs : Vector α n
ys : Vector β n
γ σ₁ ζ σ₂ : Type
s₂ : σ₂
s₁ : σ₁
f₁ : γ → σ₁ → σ₁ × ζ
f₂ : α → β → σ₂ → σ₂ × γ
⊢ mapAccumr f₁ (mapAccumr₂ f₂ xs ys s₂).2 s₁ =
    let m :=
      mapAccumr₂
        (fun x y s =>
          let r₂ := f₂ x y s.2;
          let r₁ := f₁ r₂.2 s.1;
          ((r₁.1, r₂.1), r₁.2))
        xs ys (s₁, s₂);
    (m.1.1, m.2)
state_after: no goals