1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: FormalMultilinearSeries.leftInv_eq_rightInv
File: Mathlib/Analysis/Analytic/Inverse.lean

tactic: rw [leftInv_removeZero]
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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p.leftInv i = p.removeZero.leftInv i
state_after: no goals

tactic: apply leftInv_eq_rightInv_aux <;> simp
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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p.removeZero.leftInv i = p.removeZero.rightInv i
state_after: case h
𝕜 : 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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i

tactic: exact h
state_before: case h
𝕜 : 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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
state_after: no goals

tactic: rw [rightInv_removeZero]
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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p.removeZero.rightInv i = p.rightInv i
state_after: no goals
Theorem: Real.exp_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, exp_add, exp_neg, div_eq_mul_inv]
state_before: x y : ℝ
⊢ rexp (x - y) = rexp x / rexp y
state_after: no goals
Theorem: circleIntegral.integral_sub_center_inv
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [circleIntegral, ← div_eq_mul_inv, mul_div_cancel_left₀ _ (circleMap_ne_center hR),
  intervalIntegral.integral_const I]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
c : ℂ
R : ℝ
hR : R ≠ 0
⊢ (∮ (z : ℂ) in C(c, R), (z - c)⁻¹) = 2 * ↑π * I
state_after: no goals
Theorem: StieltjesFunction.isFiniteMeasure
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: simp [f.measure_univ hfl hfu]
state_before: f : StieltjesFunction
l u : ℝ
hfl : Tendsto (↑f) atBot (𝓝 l)
hfu : Tendsto (↑f) atTop (𝓝 u)
⊢ f.measure univ < ⊤
state_after: no goals
Theorem: Rat.divInt_div_divInt_cancel_left
File: Mathlib/Algebra/Ring/Rat.lean

tactic: rw [div_eq_mul_inv, inv_divInt', divInt_mul_divInt_cancel hx]
state_before: x : ℤ
hx : x ≠ 0
n d : ℤ
⊢ n /. x / (d /. x) = n /. d
state_after: no goals
Theorem: Finmap.insert_union
File: Mathlib/Data/Finmap.lean

tactic: simp [AList.insert_union]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s₁ s₂ : Finmap β
a₁ a₂ : AList β
⊢ insert a b (⟦a₁⟧ ∪ ⟦a₂⟧) = insert a b ⟦a₁⟧ ∪ ⟦a₂⟧
state_after: no goals
Theorem: Real.cos_two_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: gcongr
state_before: ⊢ 2 * cos 1 ^ 2 - 1 ≤ 2 * (2 / 3) ^ 2 - 1
state_after: case h.h.ha

⊢ 0 ≤ cos 1

case h.h.hab

⊢ cos 1 ≤ 2 / 3

tactic: exact cos_one_pos.le
state_before: case h.h.ha

⊢ 0 ≤ cos 1
state_after: no goals

tactic: apply cos_one_le
state_before: case h.h.hab

⊢ cos 1 ≤ 2 / 3
state_after: no goals

tactic: norm_num
state_before: ⊢ 2 * (2 / 3) ^ 2 - 1 < 0
state_after: no goals
Theorem: MeasureTheory.snorm'_measure_zero_of_exponent_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp [snorm']
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
⊢ snorm' f 0 0 = 1
state_after: no goals
Theorem: Asymptotics.isBigO_map
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def, isBigOWith_map]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k✝ : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
k : β → α
l : Filter β
⊢ f =O[map k l] g ↔ (f ∘ k) =O[l] (g ∘ k)
state_after: no goals
Theorem: PNat.find_eq_one
File: Mathlib/Data/PNat/Find.lean

tactic: simp [find_eq_iff]
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ PNat.find h = 1 ↔ p 1
state_after: no goals
Theorem: BddAbove.bddAbove_image2_of_bddBelow
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ BddAbove s → BddBelow t → BddAbove (image2 f s t)
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ upperBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (image2 f s t)

tactic: exact ⟨f a b, mem_upperBounds_image2_of_mem_upperBounds_of_mem_lowerBounds h₀ h₁ ha hb⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Monotone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ upperBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (image2 f s t)
state_after: no goals
Theorem: CategoryTheory.Presheaf.isLocallySurjective_iff_imagePresheaf_sheafify_eq_top'
File: Mathlib/CategoryTheory/Sites/LocallySurjective.lean

tactic: apply isLocallySurjective_iff_imagePresheaf_sheafify_eq_top
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ Type w
f : F ⟶ G
⊢ IsLocallySurjective J f ↔ Subpresheaf.sheafify J (imagePresheaf f) = ⊤
state_after: no goals
Theorem: Quotient.eq_mk_iff_out
File: Mathlib/Data/Quot.lean

tactic: refine Iff.trans ?_ Quotient.eq
state_before: α : Sort u_1
β : Sort u_2
s : Setoid α
x : Quotient s
y : α
⊢ x = ⟦y⟧ ↔ x.out ≈ y
state_after: α : Sort u_1
β : Sort u_2
s : Setoid α
x : Quotient s
y : α
⊢ x = ⟦y⟧ ↔ ⟦x.out⟧ = ⟦y⟧

tactic: rw [Quotient.out_eq x]
state_before: α : Sort u_1
β : Sort u_2
s : Setoid α
x : Quotient s
y : α
⊢ x = ⟦y⟧ ↔ ⟦x.out⟧ = ⟦y⟧
state_after: no goals
Theorem: ProbabilityTheory.integral_preCDF_fst
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

tactic: rw [← integral_univ, setIntegral_preCDF_fst ρ _ MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
r : ℚ
inst✝ : IsFiniteMeasure ρ
⊢ ∫ (x : α), (preCDF ρ r x).toReal ∂ρ.fst = ((ρ.IicSnd ↑r) univ).toReal
state_after: no goals
Theorem: Int.bodd_negOfNat
File: Mathlib/Data/Int/Bitwise.lean

tactic: cases n <;> simp (config := {decide := true})
state_before: n : ℕ
⊢ (negOfNat n).bodd = n.bodd
state_after: case succ
n✝ : ℕ
⊢ (negOfNat (n✝ + 1)).bodd = !n✝.bodd

tactic: rfl
state_before: case succ
n✝ : ℕ
⊢ (negOfNat (n✝ + 1)).bodd = !n✝.bodd
state_after: no goals
Theorem: Commute.sq_eq_sq_iff_eq_or_eq_neg
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [← sub_eq_zero, h.sq_sub_sq, mul_eq_zero, add_eq_zero_iff_eq_neg, sub_eq_zero, or_comm]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Ring R
a b : R
inst✝ : NoZeroDivisors R
h : Commute a b
⊢ a ^ 2 = b ^ 2 ↔ a = b ∨ a = -b
state_after: no goals
Theorem: not_primrec_ack_self
File: Mathlib/Computability/Ackermann.lean

tactic: rw [Primrec.nat_iff]
state_before: ⊢ ¬Primrec fun n => ack n n
state_after: ⊢ ¬Nat.Primrec fun n => ack n n

tactic: exact not_nat_primrec_ack_self
state_before: ⊢ ¬Nat.Primrec fun n => ack n n
state_after: no goals
Theorem: ContinuousMultilinearMap.opNorm_smul_le
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

tactic: rw [smul_apply, norm_smul, mul_assoc]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c✝ : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
c : 𝕜'
m : (i : ι) → E i
⊢ ‖(c • f) m‖ ≤ ‖c‖ * ‖f‖ * ∏ i : ι, ‖m i‖
state_after: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c✝ : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
c : 𝕜'
m : (i : ι) → E i
⊢ ‖c‖ * ‖f m‖ ≤ ‖c‖ * (‖f‖ * ∏ i : ι, ‖m i‖)

tactic: exact mul_le_mul_of_nonneg_left (le_opNorm _ _) (norm_nonneg _)
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁵ : Fintype ι
inst✝¹⁴ : Fintype ι'
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : (i : ι) → SeminormedAddCommGroup (E i)
inst✝¹¹ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁰ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁹ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁸ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁷ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
inst✝⁴ : SeminormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
c✝ : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
c : 𝕜'
m : (i : ι) → E i
⊢ ‖c‖ * ‖f m‖ ≤ ‖c‖ * (‖f‖ * ∏ i : ι, ‖m i‖)
state_after: no goals
Theorem: RCLike.smul_im
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [real_smul_eq_coe_mul, im_ofReal_mul]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
r : ℝ
z : K
⊢ im (r • z) = r * im z
state_after: no goals
Theorem: zero_eq_dist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [eq_comm, dist_eq_zero]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ 0 = dist x y ↔ x = y
state_after: no goals
Theorem: CategoryTheory.NatIso.cancel_natIso_inv_right
File: Mathlib/CategoryTheory/NatIso.lean

tactic: simp only [cancel_mono, refl]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
α : F ≅ G
X : D
Y : C
f f' : X ⟶ G.obj Y
⊢ f ≫ α.inv.app Y = f' ≫ α.inv.app Y ↔ f = f'
state_after: no goals
Theorem: Finset.comp_sup_eq_sup_comp
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [sup_cons, sup_cons, g_sup, ih, Function.comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝³ : SemilatticeSup α
inst✝² : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g✝ : β → α
a : α
inst✝¹ : SemilatticeSup γ
inst✝ : OrderBot γ
s : Finset β
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
bot : g ⊥ = ⊥
c : β
t : Finset β
hc : c ∉ t
ih : g (t.sup f) = t.sup (g ∘ f)
⊢ g ((cons c t hc).sup f) = (cons c t hc).sup (g ∘ f)
state_after: no goals
Theorem: Nat.bitwise_swap
File: Mathlib/Data/Nat/Bitwise.lean

tactic: funext m n
state_before: f : Bool → Bool → Bool
⊢ bitwise (swap f) = swap (bitwise f)
state_after: case h.h
f : Bool → Bool → Bool
m n : ℕ
⊢ bitwise (swap f) m n = swap (bitwise f) m n

tactic: simp only [Function.swap]
state_before: case h.h
f : Bool → Bool → Bool
m n : ℕ
⊢ bitwise (swap f) m n = swap (bitwise f) m n
state_after: case h.h
f : Bool → Bool → Bool
m n : ℕ
⊢ bitwise (swap f) m n = bitwise f n m

tactic: induction' m using Nat.strongInductionOn with m ih generalizing n
state_before: case h.h
f : Bool → Bool → Bool
m n : ℕ
⊢ bitwise (swap f) m n = bitwise f n m
state_after: case h.h.ind
f : Bool → Bool → Bool
m : ℕ
ih : ∀ (m_1 : ℕ), m_1 < m → ∀ (n : ℕ), bitwise (swap f) m_1 n = bitwise f n m_1
n : ℕ
⊢ bitwise (swap f) m n = bitwise f n m

tactic: cases' m with m
<;> cases' n with n
<;> try rw [bitwise_zero_left, bitwise_zero_right]
state_before: case h.h.ind
f : Bool → Bool → Bool
m : ℕ
ih : ∀ (m_1 : ℕ), m_1 < m → ∀ (n : ℕ), bitwise (swap f) m_1 n = bitwise f n m_1
n : ℕ
⊢ bitwise (swap f) m n = bitwise f n m
state_after: case h.h.ind.succ.succ
f : Bool → Bool → Bool
m : ℕ
ih : ∀ (m_1 : ℕ), m_1 < m + 1 → ∀ (n : ℕ), bitwise (swap f) m_1 n = bitwise f n m_1
n : ℕ
⊢ bitwise (swap f) (m + 1) (n + 1) = bitwise f (n + 1) (m + 1)

tactic: rw [bitwise_zero_left, bitwise_zero_right]
state_before: case h.h.ind.succ.zero
f : Bool → Bool → Bool
m : ℕ
ih : ∀ (m_1 : ℕ), m_1 < m + 1 → ∀ (n : ℕ), bitwise (swap f) m_1 n = bitwise f n m_1
⊢ bitwise (swap f) (m + 1) 0 = bitwise f 0 (m + 1)
state_after: no goals

tactic: specialize ih ((m+1) / 2) (div_lt_self' ..)
state_before: case h.h.ind.succ.succ
f : Bool → Bool → Bool
m : ℕ
ih : ∀ (m_1 : ℕ), m_1 < m + 1 → ∀ (n : ℕ), bitwise (swap f) m_1 n = bitwise f n m_1
n : ℕ
⊢ bitwise (swap f) (m + 1) (n + 1) = bitwise f (n + 1) (m + 1)
state_after: case h.h.ind.succ.succ
f : Bool → Bool → Bool
m n : ℕ
ih : ∀ (n : ℕ), bitwise (swap f) ((m + 1) / 2) n = bitwise f n ((m + 1) / 2)
⊢ bitwise (swap f) (m + 1) (n + 1) = bitwise f (n + 1) (m + 1)

tactic: simp [bitwise_of_ne_zero, ih]
state_before: case h.h.ind.succ.succ
f : Bool → Bool → Bool
m n : ℕ
ih : ∀ (n : ℕ), bitwise (swap f) ((m + 1) / 2) n = bitwise f n ((m + 1) / 2)
⊢ bitwise (swap f) (m + 1) (n + 1) = bitwise f (n + 1) (m + 1)
state_after: no goals
Theorem: Finmap.union_empty
File: Mathlib/Data/Finmap.lean

tactic: rw [← empty_toFinmap]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ∅ = ⟦s₁⟧
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ⟦∅⟧ = ⟦s₁⟧

tactic: simp [-empty_toFinmap, AList.toFinmap_eq, union_toFinmap, AList.union_assoc]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ : Finmap β
s₁ : AList β
⊢ ⟦s₁⟧ ∪ ⟦∅⟧ = ⟦s₁⟧
state_after: no goals
Theorem: Filter.eventually_nhdsSet_prod_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [eventually_nhdsSet_iff_forall, forall_prod_set, nhds_prod_eq, eventually_prod_iff]
state_before: X✝ : Type u
Y✝ : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
X : Type u_5
Y : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s : Set X
t : Set Y
x : X
p : X × Y → Prop
⊢ (∀ᶠ (q : X × Y) in 𝓝ˢ (s ×ˢ t), p q) ↔
    ∀ x ∈ s,
      ∀ y ∈ t,
        ∃ px,
          (∀ᶠ (x' : X) in 𝓝 x, px x') ∧ ∃ py, (∀ᶠ (y' : Y) in 𝓝 y, py y') ∧ ∀ {x : X}, px x → ∀ {y : Y}, py y → p (x, y)
state_after: no goals
Theorem: Vector.reverse_cons
File: Mathlib/Data/Vector/Snoc.lean

tactic: cases xs
state_before: α : Type u_1
n : ℕ
xs : Vector α n
x : α
⊢ (x ::ᵥ xs).reverse = xs.reverse.snoc x
state_after: case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : val✝.length = n
⊢ (x ::ᵥ ⟨val✝, property✝⟩).reverse = (reverse ⟨val✝, property✝⟩).snoc x

tactic: simp only [reverse, cons, toList_mk, List.reverse_cons, snoc]
state_before: case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : val✝.length = n
⊢ (x ::ᵥ ⟨val✝, property✝⟩).reverse = (reverse ⟨val✝, property✝⟩).snoc x
state_after: case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : val✝.length = n
⊢ ⟨val✝.reverse ++ [x], ⋯⟩ = append ⟨val✝.reverse, ⋯⟩ ⟨[x], ⋯⟩

tactic: congr
state_before: case mk
α : Type u_1
n : ℕ
x : α
val✝ : List α
property✝ : val✝.length = n
⊢ ⟨val✝.reverse ++ [x], ⋯⟩ = append ⟨val✝.reverse, ⋯⟩ ⟨[x], ⋯⟩
state_after: no goals
Theorem: List.getElem?_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [range'_succ]
state_before: s step n : Nat
x✝ : 0 < n + 1
⊢ (range' s (n + 1) step)[0]? = some (s + step * 0)
state_after: no goals

tactic: simp only [range'_succ, getElem?_cons_succ]
state_before: s step m n : Nat
h : m + 1 < n + 1
⊢ (range' s (n + 1) step)[m + 1]? = some (s + step * (m + 1))
state_after: s step m n : Nat
h : m + 1 < n + 1
⊢ (range' (s + step) n step)[m]? = some (s + step * (m + 1))

tactic: exact (getElem?_range' (s + step) step (Nat.lt_of_add_lt_add_right h)).trans <| by
  simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
state_before: s step m n : Nat
h : m + 1 < n + 1
⊢ (range' (s + step) n step)[m]? = some (s + step * (m + 1))
state_after: no goals

tactic: simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
state_before: s step m n : Nat
h : m + 1 < n + 1
⊢ some (s + step + step * m) = some (s + step * (m + 1))
state_after: no goals
Theorem: mem_comp_of_mem_ball
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [mem_ball_symmetry hV] at hx
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W : Set (β × β)
x y z : β
hV : SymmetricRel V
hx : x ∈ ball z V
hy : y ∈ ball z W
⊢ (x, y) ∈ V ○ W
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W : Set (β × β)
x y z : β
hV : SymmetricRel V
hx : z ∈ ball x V
hy : y ∈ ball z W
⊢ (x, y) ∈ V ○ W

tactic: exact ⟨z, hx, hy⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
V W : Set (β × β)
x y z : β
hV : SymmetricRel V
hx : z ∈ ball x V
hy : y ∈ ball z W
⊢ (x, y) ∈ V ○ W
state_after: no goals
Theorem: nhds_mul
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ 𝓝 (x * y) = map (fun x_1 => x * x_1) (map (fun x => x * y) (𝓝 1 * 𝓝 1))
state_after: no goals

tactic: rw [← map₂_mul, map_map₂, map_map₂]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map (fun x_1 => x * x_1) (map (fun x => x * y) (𝓝 1 * 𝓝 1)) = map₂ (fun a b => x * (a * b * y)) (𝓝 1) (𝓝 1)
state_after: no goals

tactic: simp only [mul_assoc]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map₂ (fun a b => x * (a * b * y)) (𝓝 1) (𝓝 1) = map₂ (fun a b => x * a * (b * y)) (𝓝 1) (𝓝 1)
state_after: no goals

tactic: rw [← map_mul_left_nhds_one x, ← map_mul_right_nhds_one y, ← map₂_mul, map₂_map_left,
  map₂_map_right]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map₂ (fun a b => x * a * (b * y)) (𝓝 1) (𝓝 1) = 𝓝 x * 𝓝 y
state_after: no goals
Theorem: Multiset.disjoint_list_sum_right
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simpa only [@disjoint_comm _ a] using disjoint_list_sum_left
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
l : List (Multiset α)
⊢ a.Disjoint l.sum ↔ ∀ b ∈ l, a.Disjoint b
state_after: no goals
Theorem: PartialHomeomorph.IsImage.closure
File: Mathlib/Topology/PartialHomeomorph.lean

tactic: simp only [mem_closure_iff_nhdsWithin_neBot, ← h.map_nhdsWithin_eq hx, map_neBot_iff]
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
s : Set X
t : Set Y
x✝ : X
y : Y
h : e.IsImage s t
x : X
hx : x ∈ e.source
⊢ ↑e x ∈ closure t ↔ x ∈ closure s
state_after: no goals
Theorem: PerfectClosure.frobenius_mk
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: simp only [frobenius_def]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ × K
⊢ (frobenius (PerfectClosure K p) p) (mk K p x) = mk K p (x.1, x.2 ^ p)
state_after: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ × K
⊢ mk K p x ^ p = mk K p (x.1, x.2 ^ p)

tactic: exact mk_pow K p x p
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : ℕ × K
⊢ mk K p x ^ p = mk K p (x.1, x.2 ^ p)
state_after: no goals
Theorem: MvPolynomial.degreeOf_lt_iff
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: rwa [degreeOf_eq_sup, Finset.sup_lt_iff]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
n : σ
f : MvPolynomial σ R
d : ℕ
h : 0 < d
⊢ degreeOf n f < d ↔ ∀ m ∈ f.support, m n < d
state_after: no goals
Theorem: nonempty_embedding_to_cardinal
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [hx]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
σ : Type u
x✝ : Nonempty (Cardinal.{u} ↪ σ)
f : Cardinal.{u} → σ
hf : Injective f
g : σ → Cardinal.{u} := invFun f
x : σ
hx : g x = 2 ^ sum g
this : g x ≤ sum g
⊢ g x > sum g
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
σ : Type u
x✝ : Nonempty (Cardinal.{u} ↪ σ)
f : Cardinal.{u} → σ
hf : Injective f
g : σ → Cardinal.{u} := invFun f
x : σ
hx : g x = 2 ^ sum g
this : g x ≤ sum g
⊢ 2 ^ sum g > sum g

tactic: exact cantor _
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
σ : Type u
x✝ : Nonempty (Cardinal.{u} ↪ σ)
f : Cardinal.{u} → σ
hf : Injective f
g : σ → Cardinal.{u} := invFun f
x : σ
hx : g x = 2 ^ sum g
this : g x ≤ sum g
⊢ 2 ^ sum g > sum g
state_after: no goals
Theorem: leftCoset_mem_leftCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [mem_leftCoset_iff, mul_mem_cancel_left (s.inv_mem ha)]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a : α
ha : a ∈ s
⊢ ∀ (x : α), x ∈ a • ↑s ↔ x ∈ ↑s
state_after: no goals