1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: dfinsupp_sumAddHom_mem
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [DFinsupp.sumAddHom_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → AddZeroClass (β i)
inst✝² : AddCommMonoid γ
S : Type u_1
inst✝¹ : SetLike S γ
inst✝ : AddSubmonoidClass S γ
s : S
f : Π₀ (i : ι), β i
g : (i : ι) → β i →+ γ
h : ∀ (c : ι), f c ≠ 0 → (g c) (f c) ∈ s
⊢ (sumAddHom g) f ∈ s
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝⁴ : DecidableEq ι
inst✝³ : (i : ι) → AddZeroClass (β i)
inst✝² : AddCommMonoid γ
S : Type u_1
inst✝¹ : SetLike S γ
inst✝ : AddSubmonoidClass S γ
s : S
f : Π₀ (i : ι), β i
g : (i : ι) → β i →+ γ
h : ∀ (c : ι), f c ≠ 0 → (g c) (f c) ∈ s
⊢ (f.sum fun x => ⇑(g x)) ∈ s
Theorem: Nat.succ_mul_choose_eq
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: decide
state_before: ⊢ succ 0 * choose 0 0 = (succ 0).choose (succ 0) * succ 0
state_after: no goals

tactic: simp [choose]
state_before: k : ℕ
⊢ succ 0 * choose 0 (k + 1) = (succ 0).choose (k + 1).succ * (k + 1).succ
state_after: no goals

tactic: simp [choose, mul_succ, Nat.add_comm]
state_before: n : ℕ
⊢ (n + 1).succ * (n + 1).choose 0 = (n + 1).succ.choose (succ 0) * succ 0
state_after: no goals

tactic: rw [choose_succ_succ (succ n) (succ k), Nat.add_mul, ← succ_mul_choose_eq n, mul_succ, ←
  succ_mul_choose_eq n, Nat.add_right_comm, ← Nat.mul_add, ← choose_succ_succ, ← succ_mul]
state_before: n k : ℕ
⊢ (n + 1).succ * (n + 1).choose (k + 1) = (n + 1).succ.choose (k + 1).succ * (k + 1).succ
state_after: no goals
Theorem: Mathlib.Tactic.Ring.coeff_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type ?u.155758
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₃ c₂ k a₁ a₂ : ℕ
x✝ : a₃ = c₂ * k
⊢ a₁ ^ a₂ * a₃ = a₁ ^ a₂ * c₂ * k
state_after: u : Lean.Level
R : Type ?u.155758
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
c₂ k a₁ a₂ : ℕ
⊢ a₁ ^ a₂ * (c₂ * k) = a₁ ^ a₂ * c₂ * k

tactic: rw [mul_assoc]
state_before: u : Lean.Level
R : Type ?u.155758
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
c₂ k a₁ a₂ : ℕ
⊢ a₁ ^ a₂ * (c₂ * k) = a₁ ^ a₂ * c₂ * k
state_after: no goals
Theorem: ProbabilityTheory.kernel.setIntegral_restrict
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [restrict_apply, Measure.restrict_restrict' hs]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α β)
s t✝ : Set β
E : Type u_4
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : β → E
a : α
hs : MeasurableSet s
t : Set β
⊢ ∫ (x : β) in t, f x ∂(kernel.restrict κ hs) a = ∫ (x : β) in t ∩ s, f x ∂κ a
state_after: no goals
Theorem: Ordinal.log_opow_mul_add
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: have hne' := (opow_mul_add_pos (zero_lt_one.trans hb).ne' u hv w).ne'
state_before: b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
⊢ log b (b ^ u * v + w) = u
state_after: b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
⊢ log b (b ^ u * v + w) = u

tactic: by_contra! hne
state_before: b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
⊢ log b (b ^ u * v + w) = u
state_after: b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
⊢ False

tactic: cases' lt_or_gt_of_ne hne with h h
state_before: b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
⊢ False
state_after: case inl
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : log b (b ^ u * v + w) < u
⊢ False

case inr
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : log b (b ^ u * v + w) > u
⊢ False

tactic: rw [← lt_opow_iff_log_lt hb hne'] at h
state_before: case inl
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : log b (b ^ u * v + w) < u
⊢ False
state_after: case inl
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : b ^ u * v + w < b ^ u
⊢ False

tactic: exact h.not_le ((le_mul_left _ (Ordinal.pos_iff_ne_zero.2 hv)).trans (le_add_right _ _))
state_before: case inl
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : b ^ u * v + w < b ^ u
⊢ False
state_after: no goals

tactic: conv at h => change u < log b (b ^ u * v + w)
state_before: case inr
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : log b (b ^ u * v + w) > u
⊢ False
state_after: case inr
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : u < log b (b ^ u * v + w)
⊢ False

tactic: rw [← succ_le_iff, ← opow_le_iff_le_log hb hne'] at h
state_before: case inr
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : u < log b (b ^ u * v + w)
⊢ False
state_after: case inr
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : b ^ succ u ≤ b ^ u * v + w
⊢ False

tactic: exact (not_lt_of_le h) (opow_mul_add_lt_opow_succ hvb hw)
state_before: case inr
b u v w : Ordinal.{u_1}
hb : 1 < b
hv : v ≠ 0
hvb : v < b
hw : w < b ^ u
hne' : b ^ u * v + w ≠ 0
hne : log b (b ^ u * v + w) ≠ u
h : b ^ succ u ≤ b ^ u * v + w
⊢ False
state_after: no goals
Theorem: le_one_of_mul_le_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

tactic: simpa only [one_mul]
state_before: α : Type u_1
β : Type u_2
inst✝² : MulOneClass α
inst✝¹ : LE α
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
h : a * b ≤ b
⊢ a * ?m.22435 ≤ 1 * ?m.22435
state_after: no goals
Theorem: List.suffix_cons_iff
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: constructor
state_before: α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+ a :: l₂ ↔ l₁ = a :: l₂ ∨ l₁ <:+ l₂
state_after: case mp
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+ a :: l₂ → l₁ = a :: l₂ ∨ l₁ <:+ l₂

case mpr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ → l₁ <:+ a :: l₂

tactic: rintro ⟨⟨hd, tl⟩, hl₃⟩
state_before: case mp
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ <:+ a :: l₂ → l₁ = a :: l₂ ∨ l₁ <:+ l₂
state_after: case mp.intro.nil
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
hl₃ : [] ++ l₁ = a :: l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂

case mp.intro.cons
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ : List α✝
hl₃ : head✝ :: tail✝ ++ l₁ = a :: l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂

tactic: exact Or.inl hl₃
state_before: case mp.intro.nil
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
hl₃ : [] ++ l₁ = a :: l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂
state_after: no goals

tactic: simp only [cons_append] at hl₃
state_before: case mp.intro.cons
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ : List α✝
hl₃ : head✝ :: tail✝ ++ l₁ = a :: l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂
state_after: case mp.intro.cons
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ : List α✝
hl₃ : head✝ :: (tail✝ ++ l₁) = a :: l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂

tactic: injection hl₃ with _ hl₄
state_before: case mp.intro.cons
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ : List α✝
hl₃ : head✝ :: (tail✝ ++ l₁) = a :: l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂
state_after: case mp.intro.cons
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ : List α✝
head_eq✝ : head✝ = a
hl₄ : tail✝ ++ l₁ = l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂

tactic: exact Or.inr ⟨_, hl₄⟩
state_before: case mp.intro.cons
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
head✝ : α✝
tail✝ : List α✝
head_eq✝ : head✝ = a
hl₄ : tail✝ ++ l₁ = l₂
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂
state_after: no goals

tactic: rintro (rfl | hl₁)
state_before: case mpr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
⊢ l₁ = a :: l₂ ∨ l₁ <:+ l₂ → l₁ <:+ a :: l₂
state_after: case mpr.inl
α✝ : Type u_1
a : α✝
l₂ : List α✝
⊢ a :: l₂ <:+ a :: l₂

case mpr.inr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
hl₁ : l₁ <:+ l₂
⊢ l₁ <:+ a :: l₂

tactic: exact (a :: l₂).suffix_refl
state_before: case mpr.inl
α✝ : Type u_1
a : α✝
l₂ : List α✝
⊢ a :: l₂ <:+ a :: l₂
state_after: no goals

tactic: exact hl₁.trans (l₂.suffix_cons _)
state_before: case mpr.inr
α✝ : Type u_1
l₁ : List α✝
a : α✝
l₂ : List α✝
hl₁ : l₁ <:+ l₂
⊢ l₁ <:+ a :: l₂
state_after: no goals
Theorem: MeasureTheory.AEDisjoint.iUnion_right_iff
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

tactic: simp only [AEDisjoint, inter_iUnion, measure_iUnion_null_iff]
state_before: ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s t✝ u v : Set α
inst✝ : Countable ι
t : ι → Set α
⊢ AEDisjoint μ s (⋃ i, t i) ↔ ∀ (i : ι), AEDisjoint μ s (t i)
state_after: no goals
Theorem: uniqueMDiffWithinAt_iff_uniqueDiffWithinAt
File: Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean

tactic: simp only [UniqueMDiffWithinAt, mfld_simps]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹ : NormedAddCommGroup E'
inst✝ : NormedSpace 𝕜 E'
f : E → E'
s : Set E
x : E
⊢ UniqueMDiffWithinAt 𝓘(𝕜, E) s x ↔ UniqueDiffWithinAt 𝕜 s x
state_after: no goals
Theorem: Finset.mulEnergy_pos_iff
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: simp_rw [not_and_or, not_nonempty_iff_eq_empty] at H
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : ¬(s.Nonempty ∧ t.Nonempty)
⊢ False
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : s = ∅ ∨ t = ∅
⊢ False

tactic: obtain rfl | rfl := H <;> simp [Nat.not_lt_zero] at h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
h : 0 < Eₘ[s, t]
H : s = ∅ ∨ t = ∅
⊢ False
state_after: no goals
Theorem: Topology.IsUpperSet.monotone_to_upperTopology_continuous
File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

tactic: simp_rw [continuous_def, isOpen_iff_isUpperSet]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper β
f : α → β
hf : Monotone f
⊢ Continuous f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper β
f : α → β
hf : Monotone f
⊢ ∀ (s : Set β), IsOpen s → IsUpperSet (f ⁻¹' s)

tactic: intro s hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper β
f : α → β
hf : Monotone f
⊢ ∀ (s : Set β), IsOpen s → IsUpperSet (f ⁻¹' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper β
f : α → β
hf : Monotone f
s : Set β
hs : IsOpen s
⊢ IsUpperSet (f ⁻¹' s)

tactic: exact (IsUpper.isUpperSet_of_isOpen hs).preimage hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsUpperSet α
inst✝ : IsUpper β
f : α → β
hf : Monotone f
s : Set β
hs : IsOpen s
⊢ IsUpperSet (f ⁻¹' s)
state_after: no goals
Theorem: Padic.valuation_p
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have h : (1 : ℝ) < p := mod_cast (Fact.out : p.Prime).one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ (↑p).valuation = 1
state_after: p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ (↑p).valuation = 1

tactic: refine neg_injective ((zpow_strictMono h).injective <| (norm_eq_pow_val ?_).symm.trans ?_)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ (↑p).valuation = 1
state_after: case refine_1
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ↑p ≠ 0

case refine_2
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ‖↑p‖ = ↑p ^ (-1)

tactic: exact mod_cast (Fact.out : p.Prime).ne_zero
state_before: case refine_1
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ↑p ≠ 0
state_after: no goals

tactic: simp
state_before: case refine_2
p : ℕ
hp : Fact (Nat.Prime p)
h : 1 < ↑p
⊢ ‖↑p‖ = ↑p ^ (-1)
state_after: no goals
Theorem: sigmaFinsuppEquivDFinsupp_add
File: Mathlib/Data/Finsupp/ToDFinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝¹ : Semiring R
inst✝ : AddZeroClass N
f g : (i : ι) × η i →₀ N
⊢ sigmaFinsuppEquivDFinsupp (f + g) = sigmaFinsuppEquivDFinsupp f + sigmaFinsuppEquivDFinsupp g
state_after: case h.h
ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝¹ : Semiring R
inst✝ : AddZeroClass N
f g : (i : ι) × η i →₀ N
i✝ : ι
a✝ : η i✝
⊢ ((sigmaFinsuppEquivDFinsupp (f + g)) i✝) a✝ = ((sigmaFinsuppEquivDFinsupp f + sigmaFinsuppEquivDFinsupp g) i✝) a✝

tactic: rfl
state_before: case h.h
ι : Type u_1
R : Type u_2
M : Type u_3
η : ι → Type u_4
N : Type u_5
inst✝¹ : Semiring R
inst✝ : AddZeroClass N
f g : (i : ι) × η i →₀ N
i✝ : ι
a✝ : η i✝
⊢ ((sigmaFinsuppEquivDFinsupp (f + g)) i✝) a✝ = ((sigmaFinsuppEquivDFinsupp f + sigmaFinsuppEquivDFinsupp g) i✝) a✝
state_after: no goals
Theorem: Fin.predAbove_succAbove
File: Mathlib/Data/Fin/Basic.lean

tactic: obtain h | h := p.le_or_lt i
state_before: n m : ℕ
p i : Fin n
⊢ p.predAbove (p.castSucc.succAbove i) = i
state_after: case inl
n m : ℕ
p i : Fin n
h : p ≤ i
⊢ p.predAbove (p.castSucc.succAbove i) = i

case inr
n m : ℕ
p i : Fin n
h : i < p
⊢ p.predAbove (p.castSucc.succAbove i) = i

tactic: rw [succAbove_castSucc_of_le _ _ h, predAbove_succ_of_le _ _ h]
state_before: case inl
n m : ℕ
p i : Fin n
h : p ≤ i
⊢ p.predAbove (p.castSucc.succAbove i) = i
state_after: no goals

tactic: rw [succAbove_castSucc_of_lt _ _ h, predAbove_castSucc_of_le _ _ $ Fin.le_of_lt h]
state_before: case inr
n m : ℕ
p i : Fin n
h : i < p
⊢ p.predAbove (p.castSucc.succAbove i) = i
state_after: no goals
Theorem: jacobiSym.eq_neg_one_at_prime_divisor_of_eq_neg_one
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: have hn₀ : n ≠ 0 := by
  rintro rfl
  rw [zero_right, eq_neg_self_iff] at h
  exact one_ne_zero h
state_before: a : ℤ
n : ℕ
h : J(a | n) = -1
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1
state_after: a : ℤ
n : ℕ
h : J(a | n) = -1
hn₀ : n ≠ 0
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1

tactic: have hf₀ : ∀ p ∈ n.factors, p ≠ 0 := fun p hp => (Nat.pos_of_mem_factors hp).ne.symm
state_before: a : ℤ
n : ℕ
h : J(a | n) = -1
hn₀ : n ≠ 0
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1
state_after: a : ℤ
n : ℕ
h : J(a | n) = -1
hn₀ : n ≠ 0
hf₀ : ∀ p ∈ n.factors, p ≠ 0
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1

tactic: rw [← Nat.prod_factors hn₀, list_prod_right hf₀] at h
state_before: a : ℤ
n : ℕ
h : J(a | n) = -1
hn₀ : n ≠ 0
hf₀ : ∀ p ∈ n.factors, p ≠ 0
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1
state_after: a : ℤ
n : ℕ
h : (List.map (fun n => J(a | n)) n.factors).prod = -1
hn₀ : n ≠ 0
hf₀ : ∀ p ∈ n.factors, p ≠ 0
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1

tactic: obtain ⟨p, hmem, hj⟩ := List.mem_map.mp (List.neg_one_mem_of_prod_eq_neg_one h)
state_before: a : ℤ
n : ℕ
h : (List.map (fun n => J(a | n)) n.factors).prod = -1
hn₀ : n ≠ 0
hf₀ : ∀ p ∈ n.factors, p ≠ 0
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1
state_after: case intro.intro
a : ℤ
n : ℕ
h : (List.map (fun n => J(a | n)) n.factors).prod = -1
hn₀ : n ≠ 0
hf₀ : ∀ p ∈ n.factors, p ≠ 0
p : ℕ
hmem : p ∈ n.factors
hj : J(a | p) = -1
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1

tactic: exact ⟨p, Nat.prime_of_mem_factors hmem, Nat.dvd_of_mem_factors hmem, hj⟩
state_before: case intro.intro
a : ℤ
n : ℕ
h : (List.map (fun n => J(a | n)) n.factors).prod = -1
hn₀ : n ≠ 0
hf₀ : ∀ p ∈ n.factors, p ≠ 0
p : ℕ
hmem : p ∈ n.factors
hj : J(a | p) = -1
⊢ ∃ p, Nat.Prime p ∧ p ∣ n ∧ J(a | p) = -1
state_after: no goals

tactic: rintro rfl
state_before: a : ℤ
n : ℕ
h : J(a | n) = -1
⊢ n ≠ 0
state_after: a : ℤ
h : J(a | 0) = -1
⊢ False

tactic: rw [zero_right, eq_neg_self_iff] at h
state_before: a : ℤ
h : J(a | 0) = -1
⊢ False
state_after: a : ℤ
h : 1 = 0
⊢ False

tactic: exact one_ne_zero h
state_before: a : ℤ
h : 1 = 0
⊢ False
state_after: no goals
Theorem: Matrix.isHermitian_inv
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: rw [← inv_inv_of_invertible A]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝⁴ : CommRing α
inst✝³ : StarRing α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
A : Matrix m m α
inst✝ : Invertible A
h : A⁻¹.IsHermitian
⊢ A.IsHermitian
state_after: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝⁴ : CommRing α
inst✝³ : StarRing α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
A : Matrix m m α
inst✝ : Invertible A
h : A⁻¹.IsHermitian
⊢ A⁻¹⁻¹.IsHermitian

tactic: exact IsHermitian.inv h
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
A✝ : Matrix n n α
inst✝⁴ : CommRing α
inst✝³ : StarRing α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
A : Matrix m m α
inst✝ : Invertible A
h : A⁻¹.IsHermitian
⊢ A⁻¹⁻¹.IsHermitian
state_after: no goals
Theorem: Num.castNum_ldiff
File: Mathlib/Data/Num/Lemmas.lean

tactic: apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> rfl
state_before: α : Type u_1
⊢ ∀ (m n : Num), ↑(m.ldiff n) = (↑m).ldiff ↑n
state_after: no goals

tactic: try cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ (PosNum.bit a✝ m✝).ldiff (PosNum.bit b✝ n✝) = bit (a✝ && !b✝) (m✝.ldiff n✝)
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).ldiff (PosNum.bit false n✝) = bit (false && !false) (m✝.ldiff n✝)

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).ldiff (PosNum.bit true n✝) = bit (false && !true) (m✝.ldiff n✝)

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).ldiff (PosNum.bit false n✝) = bit (true && !false) (m✝.ldiff n✝)

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).ldiff (PosNum.bit true n✝) = bit (true && !true) (m✝.ldiff n✝)

tactic: cases_type* Bool
state_before: case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ (PosNum.bit a✝ m✝).ldiff (PosNum.bit b✝ n✝) = bit (a✝ && !b✝) (m✝.ldiff n✝)
state_after: case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).ldiff (PosNum.bit false n✝) = bit (false && !false) (m✝.ldiff n✝)

case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit false m✝).ldiff (PosNum.bit true n✝) = bit (false && !true) (m✝.ldiff n✝)

case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).ldiff (PosNum.bit false n✝) = bit (true && !false) (m✝.ldiff n✝)

case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ (PosNum.bit true m✝).ldiff (PosNum.bit true n✝) = bit (true && !true) (m✝.ldiff n✝)
Theorem: MeasureTheory.IsFundamentalDomain.projection_respects_measure_apply
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [fund_dom_t.projection_respects_measure (μ := μ), measure_map_restrict_apply ν t meas_U]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MeasurableSpace α
ν : Measure α
μ : Measure (Quotient α_mod_G)
i : QuotientMeasureEqMeasurePreimage ν μ
t : Set α
fund_dom_t : IsFundamentalDomain G t ν
U : Set (Quotient α_mod_G)
meas_U : MeasurableSet U
⊢ μ U = ν (Quotient.mk α_mod_G ⁻¹' U ∩ t)
state_after: no goals
Theorem: Matrix.inv_inv_of_invertible
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp only [← invOf_eq_nonsing_inv, invOf_invOf]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
⊢ A⁻¹⁻¹ = A
state_after: no goals
Theorem: Set.image_mul_right_Icc'
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [h, division_def]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ ⇑(Equiv.symm (Units.mk0 c ⋯).mulRight) ⁻¹' Icc a b = Icc (a * c) (b * c)
state_after: no goals
Theorem: MeasureTheory.eventually_div_right_iff
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: conv_rhs => rw [Filter.Eventually, ← map_div_right_ae μ t]
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulRightInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x / t)) ↔ ∀ᵐ (x : G) ∂μ, p x
state_after: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulRightInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x / t)) ↔ {x | p x} ∈ Filter.map (fun t_1 => t_1 / t) (ae μ)

tactic: rfl
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : μ.IsMulRightInvariant
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x / t)) ↔ {x | p x} ∈ Filter.map (fun t_1 => t_1 / t) (ae μ)
state_after: no goals
Theorem: sub_pow_char_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [eq_sub_iff_add_eq, ← add_pow_char_of_commute _ _ _ (Commute.sub_left h rfl)]
state_before: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y) ^ p = x ^ p - y ^ p
state_after: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y + y) ^ p = x ^ p

tactic: simp
state_before: R : Type u_1
inst✝² : Ring R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x - y + y) ^ p = x ^ p
state_after: no goals
Theorem: CategoryTheory.Limits.spanExt_app_one
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.zero = iX
state_after: no goals
Theorem: tendsto_pow_atTop_nhds_zero_of_lt_one
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simp [_root_.pow_succ, ← hr, tendsto_const_nhds]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
r : 𝕜
h₁ : 0 ≤ r
h₂ : r < 1
hr : 0 = r
⊢ Tendsto (fun n => r ^ (n + 1)) atTop (𝓝 0)
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
inst✝² : Archimedean 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
r : 𝕜
h₁ : 0 ≤ r
h₂ : r < 1
hr : 0 < r
this : Tendsto (fun n => r⁻¹ ^ n) atTop atTop
n : ℕ
⊢ ((fun r => r⁻¹) ∘ fun n => r⁻¹ ^ n) n = r ^ n
state_after: no goals
Theorem: List.mem_of_mem_inter_right
File: Mathlib/Data/List/Lattice.lean

tactic: simpa using of_mem_filter h
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
h : a ∈ l₁ ∩ l₂
⊢ a ∈ l₂
state_after: no goals
Theorem: ProbabilityTheory.gaussianPDFReal_nonneg
File: Mathlib/Probability/Distributions/Gaussian.lean

tactic: rw [gaussianPDFReal]
state_before: μ : ℝ
v : ℝ≥0
x : ℝ
⊢ 0 ≤ gaussianPDFReal μ v x
state_after: μ : ℝ
v : ℝ≥0
x : ℝ
⊢ 0 ≤ (√(2 * π * ↑v))⁻¹ * rexp (-(x - μ) ^ 2 / (2 * ↑v))

tactic: positivity
state_before: μ : ℝ
v : ℝ≥0
x : ℝ
⊢ 0 ≤ (√(2 * π * ↑v))⁻¹ * rexp (-(x - μ) ^ 2 / (2 * ↑v))
state_after: no goals