1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.div_pow
File: Mathlib/Data/Nat/Defs.lean

tactic: obtain rfl | hc := c.eq_zero_or_pos
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
⊢ (b / a) ^ c = b ^ c / a ^ c
state_after: case inl
a b d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
⊢ (b / a) ^ 0 = b ^ 0 / a ^ 0

case inr
a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
hc : c > 0
⊢ (b / a) ^ c = b ^ c / a ^ c

tactic: obtain rfl | ha := a.eq_zero_or_pos
state_before: case inr
a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
hc : c > 0
⊢ (b / a) ^ c = b ^ c / a ^ c
state_after: case inr.inl
b c d m n k : ℕ
p q : ℕ → Prop
hc : c > 0
h : 0 ∣ b
⊢ (b / 0) ^ c = b ^ c / 0 ^ c

case inr.inr
a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
hc : c > 0
ha : a > 0
⊢ (b / a) ^ c = b ^ c / a ^ c

tactic: refine (Nat.div_eq_of_eq_mul_right (pos_pow_of_pos c ha) ?_).symm
state_before: case inr.inr
a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
hc : c > 0
ha : a > 0
⊢ (b / a) ^ c = b ^ c / a ^ c
state_after: case inr.inr
a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
hc : c > 0
ha : a > 0
⊢ b ^ c = a ^ c * (b / a) ^ c

tactic: rw [← Nat.mul_pow, Nat.mul_div_cancel_left' h]
state_before: case inr.inr
a b c d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
hc : c > 0
ha : a > 0
⊢ b ^ c = a ^ c * (b / a) ^ c
state_after: no goals

tactic: simp
state_before: case inl
a b d m n k : ℕ
p q : ℕ → Prop
h : a ∣ b
⊢ (b / a) ^ 0 = b ^ 0 / a ^ 0
state_after: no goals

tactic: simp [Nat.zero_pow hc]
state_before: case inr.inl
b c d m n k : ℕ
p q : ℕ → Prop
hc : c > 0
h : 0 ∣ b
⊢ (b / 0) ^ c = b ^ c / 0 ^ c
state_after: no goals
Theorem: Setoid.classes_eqv_classes
File: Mathlib/Data/Setoid/Partition.lean

tactic: rintro y ⟨⟨_, rfl⟩, ha⟩
state_before: α : Type u_1
r : Setoid α
a : α
⊢ ∀ (y : Set α), y ∈ r.classes ∧ a ∈ y → y = {x | r.Rel x a}
state_after: case intro.intro
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
⊢ {x | r.Rel x w✝} = {x | r.Rel x a}

tactic: ext x
state_before: case intro.intro
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
⊢ {x | r.Rel x w✝} = {x | r.Rel x a}
state_after: case intro.intro.h
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
x : α
⊢ x ∈ {x | r.Rel x w✝} ↔ x ∈ {x | r.Rel x a}

tactic: exact ⟨fun hx => r.trans' hx (r.symm' ha), fun hx => r.trans' hx ha⟩
state_before: case intro.intro.h
α : Type u_1
r : Setoid α
a w✝ : α
ha : a ∈ {x | r.Rel x w✝}
x : α
⊢ x ∈ {x | r.Rel x w✝} ↔ x ∈ {x | r.Rel x a}
state_after: no goals
Theorem: Equiv.right_vsub_pointReflection
File: Mathlib/Algebra/AddTorsor.lean

tactic: simp [← neg_nsmul]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
x y : P
⊢ -(y -ᵥ (pointReflection x) y) = -(2 • (y -ᵥ x))
state_after: no goals
Theorem: symmDiff_eq_sup_sdiff_inf
File: Mathlib/Order/SymmDiff.lean

tactic: simp [sup_sdiff, symmDiff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b = (a ⊔ b) \ (a ⊓ b)
state_after: no goals
Theorem: Nat.coprime_mul_iff_right
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: rw [@coprime_comm k, @coprime_comm k, @coprime_comm k, coprime_mul_iff_left]
state_before: k m n : Nat
⊢ k.Coprime (m * n) ↔ k.Coprime m ∧ k.Coprime n
state_after: no goals
Theorem: bernsteinPolynomial.iterate_derivative_at_1
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: rw [flip' _ _ _ h]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ eval 1 ((⇑derivative)^[n - ν] (bernsteinPolynomial R n ν)) = (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))
state_after: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ eval 1 ((⇑derivative)^[n - ν] ((bernsteinPolynomial R n (n - ν)).comp (1 - X))) =
    (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))

tactic: simp [Polynomial.eval_comp, h]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ eval 1 ((⇑derivative)^[n - ν] ((bernsteinPolynomial R n (n - ν)).comp (1 - X))) =
    (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))
state_after: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ (-1) ^ (n - ν) * eval (↑(n - (n - ν - 1))) (ascPochhammer R (n - ν)) =
    (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))

tactic: obtain rfl | h' := h.eq_or_lt
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ (-1) ^ (n - ν) * eval (↑(n - (n - ν - 1))) (ascPochhammer R (n - ν)) =
    (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))
state_after: case inl
R : Type u_1
inst✝ : CommRing R
ν : ℕ
h : ν ≤ ν
⊢ (-1) ^ (ν - ν) * eval (↑(ν - (ν - ν - 1))) (ascPochhammer R (ν - ν)) =
    (-1) ^ (ν - ν) * eval (↑ν + 1) (ascPochhammer R (ν - ν))

case inr
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
h' : ν < n
⊢ (-1) ^ (n - ν) * eval (↑(n - (n - ν - 1))) (ascPochhammer R (n - ν)) =
    (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))

tactic: simp
state_before: case inl
R : Type u_1
inst✝ : CommRing R
ν : ℕ
h : ν ≤ ν
⊢ (-1) ^ (ν - ν) * eval (↑(ν - (ν - ν - 1))) (ascPochhammer R (ν - ν)) =
    (-1) ^ (ν - ν) * eval (↑ν + 1) (ascPochhammer R (ν - ν))
state_after: no goals

tactic: norm_cast
state_before: case inr
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
h' : ν < n
⊢ (-1) ^ (n - ν) * eval (↑(n - (n - ν - 1))) (ascPochhammer R (n - ν)) =
    (-1) ^ (n - ν) * eval (↑ν + 1) (ascPochhammer R (n - ν))
state_after: case inr
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
h' : ν < n
⊢ ↑(Int.negSucc 0 ^ (n - ν)) * ↑(eval (n - (n - ν - 1)) (ascPochhammer ℕ (n - ν))) =
    ↑(Int.negSucc 0 ^ (n - ν)) * ↑(eval (ν + 1) (ascPochhammer ℕ (n - ν)))

tactic: congr
state_before: case inr
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
h' : ν < n
⊢ ↑(Int.negSucc 0 ^ (n - ν)) * ↑(eval (n - (n - ν - 1)) (ascPochhammer ℕ (n - ν))) =
    ↑(Int.negSucc 0 ^ (n - ν)) * ↑(eval (ν + 1) (ascPochhammer ℕ (n - ν)))
state_after: case inr.e_a.e_a.e_a
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
h' : ν < n
⊢ n - (n - ν - 1) = ν + 1

tactic: omega
state_before: case inr.e_a.e_a.e_a
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
h' : ν < n
⊢ n - (n - ν - 1) = ν + 1
state_after: no goals
Theorem: Real.sInf_le_iff
File: Mathlib/Data/Real/Archimedean.lean

tactic: rw [le_iff_forall_pos_lt_add]
state_before: s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
⊢ sInf s ≤ a ↔ ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
state_after: s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → sInf s < a + ε) ↔ ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε

tactic: constructor <;> intro H ε ε_pos
state_before: s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
⊢ (∀ (ε : ℝ), 0 < ε → sInf s < a + ε) ↔ ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
state_after: case mp
s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → sInf s < a + ε
ε : ℝ
ε_pos : 0 < ε
⊢ ∃ x ∈ s, x < a + ε

case mpr
s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
ε : ℝ
ε_pos : 0 < ε
⊢ sInf s < a + ε

tactic: exact exists_lt_of_csInf_lt h' (H ε ε_pos)
state_before: case mp
s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → sInf s < a + ε
ε : ℝ
ε_pos : 0 < ε
⊢ ∃ x ∈ s, x < a + ε
state_after: no goals

tactic: rcases H ε ε_pos with ⟨x, x_in, hx⟩
state_before: case mpr
s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
ε : ℝ
ε_pos : 0 < ε
⊢ sInf s < a + ε
state_after: case mpr.intro.intro
s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
ε : ℝ
ε_pos : 0 < ε
x : ℝ
x_in : x ∈ s
hx : x < a + ε
⊢ sInf s < a + ε

tactic: exact csInf_lt_of_lt h x_in hx
state_before: case mpr.intro.intro
s : Set ℝ
h : BddBelow s
h' : s.Nonempty
a : ℝ
H : ∀ (ε : ℝ), 0 < ε → ∃ x ∈ s, x < a + ε
ε : ℝ
ε_pos : 0 < ε
x : ℝ
x_in : x ∈ s
hx : x < a + ε
⊢ sInf s < a + ε
state_after: no goals
Theorem: Submodule.sup_set_smul
File: Mathlib/Algebra/Module/Submodule/Pointwise.lean

tactic: rintro _ _ (hr|hr) hn
state_before: α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
⊢ ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s ⊔ t → n ∈ N → r • n ∈ s • N ⊔ t • N
state_after: case inl
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
r✝ : S
n✝ : M
hr : r✝ ∈ s
hn : n✝ ∈ N
⊢ r✝ • n✝ ∈ s • N ⊔ t • N

case inr
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
r✝ : S
n✝ : M
hr : r✝ ∈ t
hn : n✝ ∈ N
⊢ r✝ • n✝ ∈ s • N ⊔ t • N

tactic: exact Submodule.mem_sup_left (mem_set_smul_of_mem_mem hr hn)
state_before: case inl
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
r✝ : S
n✝ : M
hr : r✝ ∈ s
hn : n✝ ∈ N
⊢ r✝ • n✝ ∈ s • N ⊔ t • N
state_after: no goals

tactic: exact Submodule.mem_sup_right (mem_set_smul_of_mem_mem hr hn)
state_before: case inr
α : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
S : Type u_4
inst✝³ : Monoid S
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DistribMulAction S M
sR : Set R
s✝ : Set S
N : Submodule R M
s t : Set S
r✝ : S
n✝ : M
hr : r✝ ∈ t
hn : n✝ ∈ N
⊢ r✝ • n✝ ∈ s • N ⊔ t • N
state_after: no goals
Theorem: Equiv.Perm.Disjoint.support_mul
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: refine le_antisymm (support_mul_le _ _) fun a => ?_
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.Disjoint g
⊢ (f * g).support = f.support ∪ g.support
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.Disjoint g
a : α
⊢ a ∈ f.support ∪ g.support → a ∈ (f * g).support

tactic: rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.Disjoint g
a : α
⊢ a ∈ f.support ∪ g.support → a ∈ (f * g).support
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.Disjoint g
a : α
⊢ f (g a) = a → f a = a ∧ g a = a

tactic: exact
  (h a).elim (fun hf h => ⟨hf, f.apply_eq_iff_eq.mp (h.trans hf.symm)⟩) fun hg h =>
    ⟨(congr_arg f hg).symm.trans h, hg⟩
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : f.Disjoint g
a : α
⊢ f (g a) = a → f a = a ∧ g a = a
state_after: no goals
Theorem: Nat.one_bits
File: Mathlib/Data/Nat/Bits.lean

tactic: convert bit1_bits 0
state_before: m n : ℕ
⊢ bits 1 = [true]
state_after: no goals
Theorem: List.zipWith_rotate_distrib
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_drop_append_take_mod, rotate_eq_drop_append_take_mod,
  rotate_eq_drop_append_take_mod, h, zipWith_append, ← zipWith_distrib_drop, ←
  zipWith_distrib_take, List.length_zipWith, h, min_self]
state_before: α : Type u
β : Type u_1
γ : Type u_2
f : α → β → γ
l : List α
l' : List β
n : ℕ
h : l.length = l'.length
⊢ (zipWith f l l').rotate n = zipWith f (l.rotate n) (l'.rotate n)
state_after: case h
α : Type u
β : Type u_1
γ : Type u_2
f : α → β → γ
l : List α
l' : List β
n : ℕ
h : l.length = l'.length
⊢ (drop (n % l'.length) l).length = (drop (n % l'.length) l').length

tactic: rw [length_drop, length_drop, h]
state_before: case h
α : Type u
β : Type u_1
γ : Type u_2
f : α → β → γ
l : List α
l' : List β
n : ℕ
h : l.length = l'.length
⊢ (drop (n % l'.length) l).length = (drop (n % l'.length) l').length
state_after: no goals
Theorem: Sum.getRight_eq_iff
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: cases x <;> simp at h ⊢
state_before: β✝ : Type u_1
b : β✝
α✝ : Type u_2
x : α✝ ⊕ β✝
h : x.isRight = true
⊢ x.getRight h = b ↔ x = inr b
state_after: no goals
Theorem: Int.shiftRight_coe_nat
File: Mathlib/Data/Int/Bitwise.lean

tactic: cases n <;> rfl
state_before: m n : ℕ
⊢ ↑m >>> ↑n = ↑(m >>> n)
state_after: no goals
Theorem: add_tsub_add_le_tsub_right
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, add_right_comm]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + c - (b + c) ≤ a - b
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + c ≤ b + (a - b) + c

tactic: exact add_le_add_right le_add_tsub c
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + c ≤ b + (a - b) + c
state_after: no goals
Theorem: upperClosure_mul
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: simp_rw [mul_comm _ t]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ↑(upperClosure s) * t = ↑(upperClosure (s * t))
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ t * ↑(upperClosure s) = ↑(upperClosure (t * s))

tactic: exact mul_upperClosure _ _
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ t * ↑(upperClosure s) = ↑(upperClosure (t * s))
state_after: no goals
Theorem: IsLocalization.integerNormalization_map_to_map
File: Mathlib/RingTheory/Localization/Integral.lean

tactic: rw [coeff_map, coeff_smul]
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
p : S[X]
b : ↥M
hb : ∀ (i : ℕ), (algebraMap R S) ((integerNormalization M p).coeff i) = ↑b • p.coeff i
i : ℕ
⊢ (Polynomial.map (algebraMap R S) (integerNormalization M p)).coeff i = (↑b • p).coeff i
state_after: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
p : S[X]
b : ↥M
hb : ∀ (i : ℕ), (algebraMap R S) ((integerNormalization M p).coeff i) = ↑b • p.coeff i
i : ℕ
⊢ (algebraMap R S) ((integerNormalization M p).coeff i) = ↑b • p.coeff i

tactic: exact hb i
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
p : S[X]
b : ↥M
hb : ∀ (i : ℕ), (algebraMap R S) ((integerNormalization M p).coeff i) = ↑b • p.coeff i
i : ℕ
⊢ (algebraMap R S) ((integerNormalization M p).coeff i) = ↑b • p.coeff i
state_after: no goals
Theorem: Algebra.TensorProduct.productMap_right_apply
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: simp
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✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
b : B
⊢ (productMap f g) (1 ⊗ₜ[R] b) = g b
state_after: no goals
Theorem: DirichletCharacter.LSeries_ne_zero_of_one_lt_re
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: simpa only [h, zero_mul, zero_ne_one] using LSeries.mul_mu_eq_one χ hs
state_before: N : ℕ
χ : DirichletCharacter ℂ N
s : ℂ
hs : 1 < s.re
h : L (fun n => χ ↑n) s = 0
⊢ False
state_after: no goals
Theorem: Submodule.liftQ_mkQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
⊢ (p.liftQ f h).comp p.mkQ = f
state_after: case h
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
x✝ : M
⊢ ((p.liftQ f h).comp p.mkQ) x✝ = f x✝

tactic: rfl
state_before: case h
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type u_3
M₂ : Type u_4
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
f : M →ₛₗ[τ₁₂] M₂
h : p ≤ ker f
x✝ : M
⊢ ((p.liftQ f h).comp p.mkQ) x✝ = f x✝
state_after: no goals
Theorem: AddCircle.coe_eq_zero_iff
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: simp [AddSubgroup.mem_zmultiples_iff]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedAddCommGroup 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p x : 𝕜
⊢ ↑x = 0 ↔ ∃ n, n • p = x
state_after: no goals
Theorem: continuousWithinAt_Ioo_iff_Ioi
File: Mathlib/Topology/Order/OrderClosed.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_Ioo_eq_nhdsWithin_Ioi h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIciTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Ioo a b) a ↔ ContinuousWithinAt f (Ioi a) a
state_after: no goals
Theorem: Sym2.mk_prod_swap_eq
File: Mathlib/Data/Sym/Sym2.lean

tactic: cases p
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α × α
⊢ Sym2.mk p.swap = Sym2.mk p
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
fst✝ snd✝ : α
⊢ Sym2.mk (fst✝, snd✝).swap = s(fst✝, snd✝)

tactic: exact eq_swap
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
fst✝ snd✝ : α
⊢ Sym2.mk (fst✝, snd✝).swap = s(fst✝, snd✝)
state_after: no goals
Theorem: Ordering.swap_swap
File: .lake/packages/batteries/Batteries/Classes/Order.lean

tactic: cases o <;> rfl
state_before: o : Ordering
⊢ o.swap.swap = o
state_after: no goals
Theorem: AnalyticAt.frequently_eq_iff_eventually_eq
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

tactic: simpa [sub_eq_zero] using frequently_zero_iff_eventually_zero (hf.sub hg)
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
hg : AnalyticAt 𝕜 g z₀
⊢ (∃ᶠ (z : 𝕜) in 𝓝[≠] z₀, f z = g z) ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = g z
state_after: no goals
Theorem: CategoryTheory.Limits.kernelIsoOfEq_refl
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: ext
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasKernel f
h : f = f
⊢ kernelIsoOfEq h = Iso.refl (kernel f)
state_after: case w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasKernel f
h : f = f
⊢ (kernelIsoOfEq h).hom ≫ equalizer.ι f 0 = (Iso.refl (kernel f)).hom ≫ equalizer.ι f 0

tactic: simp [kernelIsoOfEq]
state_before: case w.h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasKernel f
h : f = f
⊢ (kernelIsoOfEq h).hom ≫ equalizer.ι f 0 = (Iso.refl (kernel f)).hom ≫ equalizer.ι f 0
state_after: no goals
Theorem: CategoryTheory.Limits.Types.descSet_inter_of_ne
File: Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean

tactic: rw [eq_comm, ← descSet_empty hc lc, descSet_spec]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
⊢ descSet hc {x} ∩ descSet hc {y} = ∅
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
⊢ ∀ (j : J) (x_1 : K.obj j), lc.ι.app j { down := x_1 } ∈ ∅ ↔ c.ι.app j x_1 ∈ descSet hc {x} ∩ descSet hc {y}

tactic: intro j z
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
⊢ ∀ (j : J) (x_1 : K.obj j), lc.ι.app j { down := x_1 } ∈ ∅ ↔ c.ι.app j x_1 ∈ descSet hc {x} ∩ descSet hc {y}
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
⊢ lc.ι.app j { down := z } ∈ ∅ ↔ c.ι.app j z ∈ descSet hc {x} ∩ descSet hc {y}

tactic: erw [false_iff]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
⊢ lc.ι.app j { down := z } ∈ ∅ ↔ c.ι.app j z ∈ descSet hc {x} ∩ descSet hc {y}
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
⊢ c.ι.app j z ∉ descSet hc {x} ∩ descSet hc {y}

tactic: rintro ⟨hx, hy⟩
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
⊢ c.ι.app j z ∉ descSet hc {x} ∩ descSet hc {y}
state_after: case intro
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
hx : c.ι.app j z ∈ descSet hc {x}
hy : c.ι.app j z ∈ descSet hc {y}
⊢ False

tactic: rw [mem_descSet_singleton] at hx hy
state_before: case intro
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
hx : c.ι.app j z ∈ descSet hc {x}
hy : c.ι.app j z ∈ descSet hc {y}
⊢ False
state_after: case intro
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
hx : lc.ι.app j { down := z } = x
hy : lc.ι.app j { down := z } = y
⊢ False

tactic: exact hn (hx ▸ hy)
state_before: case intro
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
x y : lc.pt
hn : x ≠ y
j : J
z : K.obj j
hx : lc.ι.app j { down := z } = x
hy : lc.ι.app j { down := z } = y
⊢ False
state_after: no goals