1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Associates.mk_dvd_mk
File: Mathlib/Algebra/Associated.lean

tactic: simp only [dvd_def, mk_surjective.exists, mk_mul_mk, mk_eq_mk_iff_associated,
  Associated.comm (x := b)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ Associates.mk a ∣ Associates.mk b ↔ a ∣ b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ (∃ x, a * x ~ᵤ b) ↔ ∃ c, b = a * c

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ (∃ x, a * x ~ᵤ b) ↔ ∃ c, b = a * c
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ (∃ x, a * x ~ᵤ b) → ∃ c, b = a * c

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ (∃ c, b = a * c) → ∃ x, a * x ~ᵤ b

tactic: rintro ⟨x, u, rfl⟩
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ (∃ x, a * x ~ᵤ b) → ∃ c, b = a * c
state_after: case mp.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a x : α
u : αˣ
⊢ ∃ c, a * x * ↑u = a * c

tactic: exact ⟨_, mul_assoc ..⟩
state_before: case mp.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a x : α
u : αˣ
⊢ ∃ c, a * x * ↑u = a * c
state_after: no goals

tactic: rintro ⟨c, rfl⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a b : α
⊢ (∃ c, b = a * c) → ∃ x, a * x ~ᵤ b
state_after: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a c : α
⊢ ∃ x, a * x ~ᵤ a * c

tactic: use c
state_before: case mpr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
a c : α
⊢ ∃ x, a * x ~ᵤ a * c
state_after: no goals
Theorem: LightProfinite.pullback_fst_eq
File: Mathlib/Topology/Category/LightProfinite/Limits.lean

tactic: dsimp [pullbackIsoPullback]
state_before: X Y B : LightProfinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.fst f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.fst
state_after: X Y B : LightProfinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.fst f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.fst

tactic: simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_π]
state_before: X Y B : LightProfinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.fst f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.fst
state_after: no goals
Theorem: List.tendsto_insertNth'
File: Mathlib/Topology/List.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
n : ℕ
⊢ Tendsto (fun p => insertNth (n + 1) p.1 p.2) (𝓝 a ×ˢ 𝓝 []) (𝓝 (insertNth (n + 1) a []))
state_after: no goals

tactic: rw [this, tendsto_map'_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
n : ℕ
a' : α
l : List α
this : 𝓝 a ×ˢ 𝓝 (a' :: l) = Filter.map (fun p => (p.1, p.2.1 :: p.2.2)) (𝓝 a ×ˢ 𝓝 a' ×ˢ 𝓝 l)
⊢ Tendsto (fun p => insertNth (n + 1) p.1 p.2) (𝓝 a ×ˢ 𝓝 (a' :: l)) (𝓝 (insertNth (n + 1) a (a' :: l)))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
n : ℕ
a' : α
l : List α
this : 𝓝 a ×ˢ 𝓝 (a' :: l) = Filter.map (fun p => (p.1, p.2.1 :: p.2.2)) (𝓝 a ×ˢ 𝓝 a' ×ˢ 𝓝 l)
⊢ Tendsto ((fun p => insertNth (n + 1) p.1 p.2) ∘ fun p => (p.1, p.2.1 :: p.2.2)) (𝓝 a ×ˢ 𝓝 a' ×ˢ 𝓝 l)
    (𝓝 (insertNth (n + 1) a (a' :: l)))

tactic: exact
  (tendsto_fst.comp tendsto_snd).cons
    ((@tendsto_insertNth' _ n l).comp <| tendsto_fst.prod_mk <| tendsto_snd.comp tendsto_snd)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
n : ℕ
a' : α
l : List α
this : 𝓝 a ×ˢ 𝓝 (a' :: l) = Filter.map (fun p => (p.1, p.2.1 :: p.2.2)) (𝓝 a ×ˢ 𝓝 a' ×ˢ 𝓝 l)
⊢ Tendsto ((fun p => insertNth (n + 1) p.1 p.2) ∘ fun p => (p.1, p.2.1 :: p.2.2)) (𝓝 a ×ˢ 𝓝 a' ×ˢ 𝓝 l)
    (𝓝 (insertNth (n + 1) a (a' :: l)))
state_after: no goals

tactic: simp only [nhds_cons, Filter.prod_eq, ← Filter.map_def, ← Filter.seq_eq_filter_seq]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
n : ℕ
a' : α
l : List α
⊢ 𝓝 a ×ˢ 𝓝 (a' :: l) = Filter.map (fun p => (p.1, p.2.1 :: p.2.2)) (𝓝 a ×ˢ 𝓝 a' ×ˢ 𝓝 l)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a : α
n : ℕ
a' : α
l : List α
⊢ (Seq.seq (Prod.mk <$> 𝓝 a) fun x => Seq.seq (cons <$> 𝓝 a') fun x => 𝓝 l) =
    (fun p => (p.1, p.2.1 :: p.2.2)) <$> Seq.seq (Prod.mk <$> 𝓝 a) fun x => Seq.seq (Prod.mk <$> 𝓝 a') fun x => 𝓝 l
Theorem: Finset.sup'_image₂_le
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [sup'_le_iff, forall_image₂_iff]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁸ : DecidableEq α'
inst✝⁷ : DecidableEq β'
inst✝⁶ : DecidableEq γ
inst✝⁵ : DecidableEq γ'
inst✝⁴ : DecidableEq δ
inst✝³ : DecidableEq δ'
inst✝² : DecidableEq ε
inst✝¹ : DecidableEq ε'
f f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a✝ a' : α
b b' : β
c : γ
inst✝ : SemilatticeSup δ
g : γ → δ
a : δ
h : (image₂ f s t).Nonempty
⊢ (image₂ f s t).sup' h g ≤ a ↔ ∀ x ∈ s, ∀ y ∈ t, g (f x y) ≤ a
state_after: no goals
Theorem: Linarith.le_of_le_of_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

tactic: simp [*]
state_before: α : Type u_1
inst✝ : OrderedSemiring α
a b : α
ha : a ≤ 0
hb : b = 0
⊢ a + b ≤ 0
state_after: no goals
Theorem: HasDerivAt.mul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivAt c c' x
hd : HasDerivAt d d' x
⊢ HasDerivAt (fun y => c y * d y) (c' * d x + c x * d') x
state_after: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' univ x
hd : HasDerivWithinAt d d' univ x
⊢ HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') univ x

tactic: exact hc.mul hd
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' univ x
hd : HasDerivWithinAt d d' univ x
⊢ HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') univ x
state_after: no goals
Theorem: MulChar.one_apply_coe
File: Mathlib/NumberTheory/MulChar/Basic.lean

tactic: classical exact dif_pos a.isUnit
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
a : Rˣ
⊢ 1 ↑a = 1
state_after: no goals

tactic: exact dif_pos a.isUnit
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
a : Rˣ
⊢ 1 ↑a = 1
state_after: no goals
Theorem: Fin.coe_of_injective_castSucc_symm
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← coe_castSucc]
state_before: n✝ m n : ℕ
i : Fin n.succ
hi : i ∈ Set.range castSucc
⊢ ↑((Equiv.ofInjective castSucc ⋯).symm ⟨i, hi⟩) = ↑i
state_after: n✝ m n : ℕ
i : Fin n.succ
hi : i ∈ Set.range castSucc
⊢ ↑((Equiv.ofInjective castSucc ⋯).symm ⟨i, hi⟩).castSucc = ↑i

tactic: exact congr_arg val (Equiv.apply_ofInjective_symm _ _)
state_before: n✝ m n : ℕ
i : Fin n.succ
hi : i ∈ Set.range castSucc
⊢ ↑((Equiv.ofInjective castSucc ⋯).symm ⟨i, hi⟩).castSucc = ↑i
state_after: no goals
Theorem: Fin.map_valEmbedding_Ioo
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: simp [Ioo_eq_finset_subtype, Finset.fin, Finset.map_map]
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ioo a b) = Ioo ↑a ↑b
state_after: no goals
Theorem: Prod.mk_wcovBy_mk_iff_left
File: Mathlib/Order/Cover.lean

tactic: refine ⟨WCovBy.fst, (And.imp mk_le_mk_iff_left.2) fun h c h₁ h₂ => ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b) ⩿ (a₂, b) ↔ a₁ ⩿ a₂
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : (a₁, b) < c
h₂ : c < (a₂, b)
⊢ False

tactic: have : c.2 = b := h₂.le.2.antisymm h₁.le.2
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : (a₁, b) < c
h₂ : c < (a₂, b)
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : (a₁, b) < c
h₂ : c < (a₂, b)
this : c.2 = b
⊢ False

tactic: rw [← @Prod.mk.eta _ _ c, this, mk_lt_mk_iff_left] at h₁ h₂
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : (a₁, b) < c
h₂ : c < (a₂, b)
this : c.2 = b
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : a₁ < c.1
h₂ : c.1 < a₂
this : c.2 = b
⊢ False

tactic: exact h h₁ h₂
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : ∀ ⦃c : α⦄, a₁ < c → ¬c < a₂
c : α × β
h₁ : a₁ < c.1
h₂ : c.1 < a₂
this : c.2 = b
⊢ False
state_after: no goals
Theorem: cfc_star_id
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfc_star .., cfc_id' ..]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
⊢ cfc (fun x => star x) a = star a
state_after: no goals
Theorem: Equiv.Perm.support_conj
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: ext
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
⊢ (σ * τ * σ⁻¹).support = map (Equiv.toEmbedding σ) τ.support
state_after: case a
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
a✝ : α
⊢ a✝ ∈ (σ * τ * σ⁻¹).support ↔ a✝ ∈ map (Equiv.toEmbedding σ) τ.support

tactic: simp only [mem_map_equiv, Perm.coe_mul, Function.comp_apply, Ne, Perm.mem_support,
  Equiv.eq_symm_apply, inv_def]
state_before: case a
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
a✝ : α
⊢ a✝ ∈ (σ * τ * σ⁻¹).support ↔ a✝ ∈ map (Equiv.toEmbedding σ) τ.support
state_after: no goals
Theorem: char_prime_of_ne_zero
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: cases' CharP.char_is_prime_or_zero R p with h h
state_before: R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
⊢ Nat.Prime p
state_after: case inl
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
h : Nat.Prime p
⊢ Nat.Prime p

case inr
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
h : p = 0
⊢ Nat.Prime p

tactic: exact h
state_before: case inl
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
h : Nat.Prime p
⊢ Nat.Prime p
state_after: no goals

tactic: contradiction
state_before: case inr
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
p : ℕ
hp : CharP R p
p_ne_zero : p ≠ 0
h : p = 0
⊢ Nat.Prime p
state_after: no goals
Theorem: mul_one_add_self
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [mul_add, mul_one, mul_self, add_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : BooleanRing α
a b : α
⊢ a * (1 + a) = 0
state_after: no goals
Theorem: Composition.length_pos_of_pos
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: apply length_pos_of_sum_pos
state_before: n : ℕ
c : Composition n
h : 0 < n
⊢ 0 < c.length
state_after: case h
n : ℕ
c : Composition n
h : 0 < n
⊢ 0 < c.blocks.sum

tactic: convert h
state_before: case h
n : ℕ
c : Composition n
h : 0 < n
⊢ 0 < c.blocks.sum
state_after: case h.e'_4
n : ℕ
c : Composition n
h : 0 < n
⊢ c.blocks.sum = n

tactic: exact c.blocks_sum
state_before: case h.e'_4
n : ℕ
c : Composition n
h : 0 < n
⊢ c.blocks.sum = n
state_after: no goals
Theorem: Nat.sqrt_lt_self
File: Mathlib/Data/Nat/Defs.lean

tactic: have := Nat.mul_lt_mul_of_pos_left h (lt_of_succ_lt h)
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : 1 < n
⊢ n < n * n
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
h : 1 < n
this : n * 1 < n * n
⊢ n < n * n

tactic: rwa [Nat.mul_one] at this
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : 1 < n
this : n * 1 < n * n
⊢ n < n * n
state_after: no goals
Theorem: Multiset.addHom_ext
File: Mathlib/Data/Multiset/Basic.lean

tactic: ext s
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
⊢ f = g
state_after: case h
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
s : Multiset α
⊢ f s = g s

tactic: induction' s using Multiset.induction_on with a s ih
state_before: case h
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
s : Multiset α
⊢ f s = g s
state_after: case h.empty
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
⊢ f 0 = g 0

case h.cons
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
a : α
s : Multiset α
ih : f s = g s
⊢ f (a ::ₘ s) = g (a ::ₘ s)

tactic: simp only [_root_.map_zero]
state_before: case h.empty
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
⊢ f 0 = g 0
state_after: no goals

tactic: simp only [← singleton_add, _root_.map_add, ih, h]
state_before: case h.cons
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : AddZeroClass β
f g : Multiset α →+ β
h : ∀ (x : α), f {x} = g {x}
a : α
s : Multiset α
ih : f s = g s
⊢ f (a ::ₘ s) = g (a ::ₘ s)
state_after: no goals
Theorem: Int.bitwise_and
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ bitwise and = land
state_after: case h.h
m n : ℤ
⊢ bitwise and m n = m.land n

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
    cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
    Bool.and_false, Nat.land]
state_before: case h.h
m n : ℤ
⊢ bitwise and m n = m.land n
state_after: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise (fun x y => !x && y) m n) = -[m+1].land (ofNat n)

case h.h.negSucc.negSucc
m n : ℕ
⊢ -[Nat.bitwise (fun x y => !(!x && !y)) m n+1] = -[m+1].land -[n+1]

tactic: rfl
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ bitwise and (ofNat m) -[n+1] = (ofNat m).land -[n+1]
state_after: no goals

tactic: rw [Nat.bitwise_swap, Function.swap]
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise (fun x y => !x && y) m n) = -[m+1].land (ofNat n)
state_after: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise (fun y x => !x && y) n m) = -[m+1].land (ofNat n)

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise (fun y x => !x && y) n m) = -[m+1].land (ofNat n)
state_after: case h.h.negSucc.ofNat.e_a.e_f
m n : ℕ
⊢ (fun y x => !x && y) = fun a b => a && !b

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_a.e_f
m n : ℕ
⊢ (fun y x => !x && y) = fun a b => a && !b
state_after: case h.h.negSucc.ofNat.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!y && x) = (x && !y)

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!y && x) = (x && !y)
state_after: no goals

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ -[Nat.bitwise (fun x y => !(!x && !y)) m n+1] = -[m+1].land -[n+1]
state_after: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => !(!x && !y)) = or

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => !(!x && !y)) = or
state_after: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x && !y)) = (x || y)

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x && !y)) = (x || y)
state_after: no goals
Theorem: ContinuousLinearMap.map_sub₂
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: rw [f.map_sub, sub_apply]
state_before: 𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁵ : NormedAddCommGroup E
inst✝¹⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝¹³ : NormedAddCommGroup F
inst✝¹² : NormedSpace 𝕜 F
G : Type u_4
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedSpace 𝕜 G
R : Type u_5
𝕜₂ : Type u_6
𝕜' : Type u_7
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NontriviallyNormedField 𝕜₂
M : Type u_8
inst✝⁷ : TopologicalSpace M
σ₁₂ : 𝕜 →+* 𝕜₂
G' : Type u_9
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜₂ G'
inst✝⁴ : NormedSpace 𝕜' G'
inst✝³ : SMulCommClass 𝕜₂ 𝕜' G'
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
ρ₁₂ : R →+* 𝕜'
f : M →SL[ρ₁₂] F →SL[σ₁₂] G'
x x' : M
y : F
⊢ (f (x - x')) y = (f x) y - (f x') y
state_after: no goals
Theorem: GaussianFourier.norm_cexp_neg_mul_sq_add_mul_I
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

tactic: rw [Complex.norm_eq_abs, Complex.abs_exp, neg_mul, neg_re, ← re_add_im b]
state_before: b✝ b : ℂ
c T : ℝ
⊢ ‖cexp (-b * (↑T + ↑c * I) ^ 2)‖ = rexp (-(b.re * T ^ 2 - 2 * b.im * c * T - b.re * c ^ 2))
state_after: b✝ b : ℂ
c T : ℝ
⊢ rexp (-((↑b.re + ↑b.im * I) * (↑T + ↑c * I) ^ 2).re) =
    rexp (-((↑b.re + ↑b.im * I).re * T ^ 2 - 2 * (↑b.re + ↑b.im * I).im * c * T - (↑b.re + ↑b.im * I).re * c ^ 2))

tactic: simp only [sq, re_add_im, mul_re, mul_im, add_re, add_im, ofReal_re, ofReal_im, I_re, I_im]
state_before: b✝ b : ℂ
c T : ℝ
⊢ rexp (-((↑b.re + ↑b.im * I) * (↑T + ↑c * I) ^ 2).re) =
    rexp (-((↑b.re + ↑b.im * I).re * T ^ 2 - 2 * (↑b.re + ↑b.im * I).im * c * T - (↑b.re + ↑b.im * I).re * c ^ 2))
state_after: b✝ b : ℂ
c T : ℝ
⊢ rexp
      (-(b.re * ((T + (c * 0 - 0 * 1)) * (T + (c * 0 - 0 * 1)) - (0 + (c * 1 + 0 * 0)) * (0 + (c * 1 + 0 * 0))) -
          b.im * ((T + (c * 0 - 0 * 1)) * (0 + (c * 1 + 0 * 0)) + (0 + (c * 1 + 0 * 0)) * (T + (c * 0 - 0 * 1))))) =
    rexp (-(b.re * (T * T) - 2 * b.im * c * T - b.re * (c * c)))

tactic: ring_nf
state_before: b✝ b : ℂ
c T : ℝ
⊢ rexp
      (-(b.re * ((T + (c * 0 - 0 * 1)) * (T + (c * 0 - 0 * 1)) - (0 + (c * 1 + 0 * 0)) * (0 + (c * 1 + 0 * 0))) -
          b.im * ((T + (c * 0 - 0 * 1)) * (0 + (c * 1 + 0 * 0)) + (0 + (c * 1 + 0 * 0)) * (T + (c * 0 - 0 * 1))))) =
    rexp (-(b.re * (T * T) - 2 * b.im * c * T - b.re * (c * c)))
state_after: no goals
Theorem: Holor.slice_sum
File: Mathlib/Data/Holor.lean

tactic: letI := Classical.decEq β
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
⊢ ∑ x ∈ s, (f x).slice i hid = (∑ x ∈ s, f x).slice i hid
state_after: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∑ x ∈ s, (f x).slice i hid = (∑ x ∈ s, f x).slice i hid

tactic: refine Finset.induction_on s ?_ ?_
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∑ x ∈ s, (f x).slice i hid = (∑ x ∈ s, f x).slice i hid
state_after: case refine_1
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∑ x ∈ ∅, (f x).slice i hid = (∑ x ∈ ∅, f x).slice i hid

case refine_2
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∀ ⦃a : β⦄ {s : Finset β},
    a ∉ s →
      ∑ x ∈ s, (f x).slice i hid = (∑ x ∈ s, f x).slice i hid →
        ∑ x ∈ insert a s, (f x).slice i hid = (∑ x ∈ insert a s, f x).slice i hid

tactic: simp [slice_zero]
state_before: case refine_1
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∑ x ∈ ∅, (f x).slice i hid = (∑ x ∈ ∅, f x).slice i hid
state_after: no goals

tactic: intro _ _ h_not_in ih
state_before: case refine_2
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
⊢ ∀ ⦃a : β⦄ {s : Finset β},
    a ∉ s →
      ∑ x ∈ s, (f x).slice i hid = (∑ x ∈ s, f x).slice i hid →
        ∑ x ∈ insert a s, (f x).slice i hid = (∑ x ∈ insert a s, f x).slice i hid
state_after: case refine_2
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
a✝ : β
s✝ : Finset β
h_not_in : a✝ ∉ s✝
ih : ∑ x ∈ s✝, (f x).slice i hid = (∑ x ∈ s✝, f x).slice i hid
⊢ ∑ x ∈ insert a✝ s✝, (f x).slice i hid = (∑ x ∈ insert a✝ s✝, f x).slice i hid

tactic: rw [Finset.sum_insert h_not_in, ih, slice_add, Finset.sum_insert h_not_in]
state_before: case refine_2
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : AddCommMonoid α
β : Type
i : ℕ
hid : i < d
s : Finset β
f : β → Holor α (d :: ds)
this : DecidableEq β := Classical.decEq β
a✝ : β
s✝ : Finset β
h_not_in : a✝ ∉ s✝
ih : ∑ x ∈ s✝, (f x).slice i hid = (∑ x ∈ s✝, f x).slice i hid
⊢ ∑ x ∈ insert a✝ s✝, (f x).slice i hid = (∑ x ∈ insert a✝ s✝, f x).slice i hid
state_after: no goals
Theorem: List.bidirectionalRec_singleton
File: Mathlib/Data/List/Basic.lean

tactic: simp [bidirectionalRec]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
motive : List α → Sort u_2
nil : motive []
singleton : (a : α) → motive [a]
cons_append : (a : α) → (l : List α) → (b : α) → motive l → motive (a :: (l ++ [b]))
a : α
⊢ bidirectionalRec nil singleton cons_append [a] = singleton a
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackSymmetry_inv_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [Iso.inv_comp_eq]
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).inv ≫ pullback.snd = pullback.fst
state_after: no goals