1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: NonUnitalCommSemiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro rfl
state_before: R : Type u
inst₁ inst₂ : NonUnitalCommSemiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonUnitalCommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul

tactic: constructor <;> rfl
state_before: R : Type u
inst₁ : NonUnitalCommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
Theorem: ArithmeticFunction.moebius_apply_prime
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [moebius_apply_of_squarefree hp.squarefree, cardFactors_apply_prime hp, pow_one]
state_before: R : Type u_1
p : ℕ
hp : Nat.Prime p
⊢ μ p = -1
state_after: no goals
Theorem: eq_of_inv_mul_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: simpa using eq_inv_of_mul_eq_one_left h
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
h : a⁻¹ * b = 1
⊢ a = b
state_after: no goals
Theorem: Matrix.linfty_opNNNorm_mulVec
File: Mathlib/Analysis/Matrix.lean

tactic: rw [← linfty_opNNNorm_col (ι := Fin 1) (A *ᵥ v), ← linfty_opNNNorm_col v (ι := Fin 1)]
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : NonUnitalSeminormedRing α
A : Matrix l m α
v : m → α
⊢ ‖A *ᵥ v‖₊ ≤ ‖A‖₊ * ‖v‖₊
state_after: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : NonUnitalSeminormedRing α
A : Matrix l m α
v : m → α
⊢ ‖col (Fin 1) (A *ᵥ v)‖₊ ≤ ‖A‖₊ * ‖col (Fin 1) v‖₊

tactic: exact linfty_opNNNorm_mul A (col (Fin 1) v)
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : NonUnitalSeminormedRing α
A : Matrix l m α
v : m → α
⊢ ‖col (Fin 1) (A *ᵥ v)‖₊ ≤ ‖A‖₊ * ‖col (Fin 1) v‖₊
state_after: no goals
Theorem: Nat.min_eq_zero_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: omega
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ min m n = 0 ↔ m = 0 ∨ n = 0
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.comp_sub
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: ext p q hpq
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ z₂' : Cochain G K n₂
h : n₁ + n₂ = n₁₂
⊢ z₁.comp (z₂ - z₂') h = z₁.comp z₂ h - z₁.comp z₂' h
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ z₂' : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ (z₁.comp (z₂ - z₂') h).v p q hpq = (z₁.comp z₂ h - z₁.comp z₂' h).v p q hpq

tactic: simp only [comp_v _ _ h p _ q rfl (by omega), sub_v, comp_sub]
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ z₂' : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ (z₁.comp (z₂ - z₂') h).v p q hpq = (z₁.comp z₂ h - z₁.comp z₂' h).v p q hpq
state_after: no goals

tactic: omega
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m n₁ n₂ n₁₂ : ℤ
z₁ : Cochain F G n₁
z₂ z₂' : Cochain G K n₂
h : n₁ + n₂ = n₁₂
p q : ℤ
hpq : p + n₁₂ = q
⊢ p + n₁ + n₂ = q
state_after: no goals
Theorem: BddBelow.image2_bddAbove
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 : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ BddBelow 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 : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (image2 f s t)

tactic: exact ⟨f a b, mem_upperBounds_image2_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 : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
ha : a ∈ lowerBounds s
b : β
hb : b ∈ lowerBounds t
⊢ BddAbove (image2 f s t)
state_after: no goals
Theorem: QuaternionAlgebra.self_add_star'
File: Mathlib/Algebra/Quaternion.lean

tactic: ext <;> simp [two_mul]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a + star a = ↑(2 * a.re)
state_after: no goals
Theorem: Nat.find_eq_zero
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [find_eq_iff]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
⊢ Nat.find h = 0 ↔ p 0
state_after: no goals
Theorem: Matrix.trace_eq_zero_of_isEmpty
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

tactic: simp [trace]
state_before: ι : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype p
inst✝¹ : AddCommMonoid R
inst✝ : IsEmpty n
A : Matrix n n R
⊢ A.trace = 0
state_after: no goals
Theorem: CategoryTheory.Limits.IsInitial.strict_hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

tactic: haveI := hI.isIso_to f
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
⊢ f = g
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this : IsIso f
⊢ f = g

tactic: haveI := hI.isIso_to g
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this : IsIso f
⊢ f = g
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this✝ : IsIso f
this : IsIso g
⊢ f = g

tactic: exact eq_of_inv_eq_inv (hI.hom_ext (inv f) (inv g))
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
I : C
hI : IsInitial I
A : C
f g : A ⟶ I
this✝ : IsIso f
this : IsIso g
⊢ f = g
state_after: no goals
Theorem: WeierstrassCurve.leadingCoeff_Ψ₂Sq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: rw [leadingCoeff, W.natDegree_Ψ₂Sq h, coeff_Ψ₂Sq]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
h : 4 ≠ 0
⊢ W.Ψ₂Sq.leadingCoeff = 4
state_after: no goals
Theorem: Batteries.UnionFind.parentD_set
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: rw [parentD]
state_before: arr : Array UFNode
x : Fin arr.size
v : UFNode
i : Nat
⊢ parentD (arr.set x v) i = if ↑x = i then v.parent else parentD arr i
state_after: arr : Array UFNode
x : Fin arr.size
v : UFNode
i : Nat
⊢ (if h : i < (arr.set x v).size then ((arr.set x v).get ⟨i, h⟩).parent else i) =
    if ↑x = i then v.parent else parentD arr i

tactic: simp [Array.get_eq_getElem, parentD]
state_before: arr : Array UFNode
x : Fin arr.size
v : UFNode
i : Nat
⊢ (if h : i < (arr.set x v).size then ((arr.set x v).get ⟨i, h⟩).parent else i) =
    if ↑x = i then v.parent else parentD arr i
state_after: arr : Array UFNode
x : Fin arr.size
v : UFNode
i : Nat
⊢ (if h : i < arr.size then (arr.set x v)[i].parent else i) =
    if ↑x = i then v.parent else if h : i < arr.size then arr[i].parent else i

tactic: split <;> [split <;> simp [Array.get_set, *]; split <;> [(subst i; cases ‹¬_› x.2); rfl]]
state_before: arr : Array UFNode
x : Fin arr.size
v : UFNode
i : Nat
⊢ (if h : i < arr.size then (arr.set x v)[i].parent else i) =
    if ↑x = i then v.parent else if h : i < arr.size then arr[i].parent else i
state_after: no goals

tactic: subst i
state_before: case isFalse.isTrue
arr : Array UFNode
x : Fin arr.size
v : UFNode
i : Nat
h✝¹ : ¬i < arr.size
h✝ : ↑x = i
⊢ i = v.parent
state_after: case isFalse.isTrue
arr : Array UFNode
x : Fin arr.size
v : UFNode
h✝ : ¬↑x < arr.size
⊢ ↑x = v.parent

tactic: cases ‹¬_› x.2
state_before: case isFalse.isTrue
arr : Array UFNode
x : Fin arr.size
v : UFNode
h✝ : ¬↑x < arr.size
⊢ ↑x = v.parent
state_after: no goals
Theorem: GroupSeminorm.smul_sup
File: Mathlib/Analysis/Normed/Group/Seminorm.lean

tactic: simpa only [← smul_eq_mul, ← NNReal.smul_def, smul_one_smul ℝ≥0 r (_ : ℝ)] using
  mul_max_of_nonneg x y (r • (1 : ℝ≥0) : ℝ≥0).coe_nonneg
state_before: ι : Type u_1
R : Type u_2
R' : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
inst✝⁴ : FunLike F E ℝ
inst✝³ : Group E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
r : R
p q : GroupSeminorm E
x y : ℝ
⊢ r • max x y = max (r • x) (r • y)
state_after: no goals
Theorem: Multiset.countP_add
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [countP_eq_card_filter]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s t : Multiset α
⊢ countP p (s + t) = countP p s + countP p t
state_after: no goals
Theorem: OrderIso.map_inf
File: Mathlib/Order/Hom/Basic.lean

tactic: refine (f.toOrderEmbedding.map_inf_le x y).antisymm ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α ≃o β
x y : α
⊢ f (x ⊓ y) = f x ⊓ f y
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α ≃o β
x y : α
⊢ f.toOrderEmbedding x ⊓ f.toOrderEmbedding y ≤ f.toOrderEmbedding (x ⊓ y)

tactic: apply f.symm.le_iff_le.1
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α ≃o β
x y : α
⊢ f.toOrderEmbedding x ⊓ f.toOrderEmbedding y ≤ f.toOrderEmbedding (x ⊓ y)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α ≃o β
x y : α
⊢ f.symm (f.toOrderEmbedding x ⊓ f.toOrderEmbedding y) ≤ f.symm (f.toOrderEmbedding (x ⊓ y))

tactic: simpa using f.symm.toOrderEmbedding.map_inf_le (f x) (f y)
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α ≃o β
x y : α
⊢ f.symm (f.toOrderEmbedding x ⊓ f.toOrderEmbedding y) ≤ f.symm (f.toOrderEmbedding (x ⊓ y))
state_after: no goals
Theorem: map_symmDiff'
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [symmDiff, symmDiff, map_sup, map_sdiff', map_sdiff']
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : BooleanAlgebra α
inst✝² : BooleanAlgebra β
inst✝¹ : FunLike F α β
inst✝ : BoundedLatticeHomClass F α β
f : F
a b : α
⊢ f (a ∆ b) = f a ∆ f b
state_after: no goals
Theorem: Real.zero_rpow_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: constructor
state_before: x✝ y z x a : ℝ
⊢ 0 ^ x = a ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: case mp
x✝ y z x a : ℝ
⊢ 0 ^ x = a → x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

case mpr
x✝ y z x a : ℝ
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 → 0 ^ x = a

tactic: intro hyp
state_before: case mp
x✝ y z x a : ℝ
⊢ 0 ^ x = a → x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: case mp
x✝ y z x a : ℝ
hyp : 0 ^ x = a
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: simp only [rpow_def, Complex.ofReal_zero] at hyp
state_before: case mp
x✝ y z x a : ℝ
hyp : 0 ^ x = a
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: case mp
x✝ y z x a : ℝ
hyp : (0 ^ ↑x).re = a
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: by_cases h : x = 0
state_before: case mp
x✝ y z x a : ℝ
hyp : (0 ^ ↑x).re = a
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: case pos
x✝ y z x a : ℝ
hyp : (0 ^ ↑x).re = a
h : x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

case neg
x✝ y z x a : ℝ
hyp : (0 ^ ↑x).re = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: subst h
state_before: case pos
x✝ y z x a : ℝ
hyp : (0 ^ ↑x).re = a
h : x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: case pos
x y z a : ℝ
hyp : (0 ^ ↑0).re = a
⊢ 0 ≠ 0 ∧ a = 0 ∨ 0 = 0 ∧ a = 1

tactic: simp only [Complex.one_re, Complex.ofReal_zero, Complex.cpow_zero] at hyp
state_before: case pos
x y z a : ℝ
hyp : (0 ^ ↑0).re = a
⊢ 0 ≠ 0 ∧ a = 0 ∨ 0 = 0 ∧ a = 1
state_after: case pos
x y z a : ℝ
hyp : 1 = a
⊢ 0 ≠ 0 ∧ a = 0 ∨ 0 = 0 ∧ a = 1

tactic: exact Or.inr ⟨rfl, hyp.symm⟩
state_before: case pos
x y z a : ℝ
hyp : 1 = a
⊢ 0 ≠ 0 ∧ a = 0 ∨ 0 = 0 ∧ a = 1
state_after: no goals

tactic: rw [Complex.zero_cpow (Complex.ofReal_ne_zero.mpr h)] at hyp
state_before: case neg
x✝ y z x a : ℝ
hyp : (0 ^ ↑x).re = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: case neg
x✝ y z x a : ℝ
hyp : Complex.re 0 = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

tactic: exact Or.inl ⟨h, hyp.symm⟩
state_before: case neg
x✝ y z x a : ℝ
hyp : Complex.re 0 = a
h : ¬x = 0
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1
state_after: no goals

tactic: rintro (⟨h, rfl⟩ | ⟨rfl, rfl⟩)
state_before: case mpr
x✝ y z x a : ℝ
⊢ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 → 0 ^ x = a
state_after: case mpr.inl.intro
x✝ y z x : ℝ
h : x ≠ 0
⊢ 0 ^ x = 0

case mpr.inr.intro
x y z : ℝ
⊢ 0 ^ 0 = 1

tactic: exact zero_rpow h
state_before: case mpr.inl.intro
x✝ y z x : ℝ
h : x ≠ 0
⊢ 0 ^ x = 0
state_after: no goals

tactic: exact rpow_zero _
state_before: case mpr.inr.intro
x y z : ℝ
⊢ 0 ^ 0 = 1
state_after: no goals
Theorem: Turing.ToPartrec.Code.case_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: f g : Code
⊢ (f.case g).eval = fun v => Nat.rec (f.eval v.tail) (fun y x => g.eval (y :: v.tail)) v.headI
state_after: no goals
Theorem: Nat.ModEq.add_right_cancel
File: Mathlib/Data/Nat/ModEq.lean

tactic: rw [add_comm a, add_comm b] at h₂
state_before: m n a b c d : ℕ
h₁ : c ≡ d [MOD n]
h₂ : a + c ≡ b + d [MOD n]
⊢ a ≡ b [MOD n]
state_after: m n a b c d : ℕ
h₁ : c ≡ d [MOD n]
h₂ : c + a ≡ d + b [MOD n]
⊢ a ≡ b [MOD n]

tactic: exact h₁.add_left_cancel h₂
state_before: m n a b c d : ℕ
h₁ : c ≡ d [MOD n]
h₂ : c + a ≡ d + b [MOD n]
⊢ a ≡ b [MOD n]
state_after: no goals
Theorem: AnalyticOn.eqOn_of_preconnected_of_eventuallyEq
File: Mathlib/Analysis/Analytic/Uniqueness.lean

tactic: have hfg' : f - g =ᶠ[𝓝 z₀] 0 := hfg.mono fun z h => by simp [h]
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
f g : E → F
U : Set E
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
z₀ : E
h₀ : z₀ ∈ U
hfg : f =ᶠ[𝓝 z₀] g
⊢ EqOn f g U
state_after: 𝕜 : 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
f g : E → F
U : Set E
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
z₀ : E
h₀ : z₀ ∈ U
hfg : f =ᶠ[𝓝 z₀] g
hfg' : f - g =ᶠ[𝓝 z₀] 0
⊢ EqOn f g U

tactic: simpa [sub_eq_zero] using fun z hz =>
  (hf.sub hg).eqOn_zero_of_preconnected_of_eventuallyEq_zero hU h₀ hfg' hz
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
f g : E → F
U : Set E
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
z₀ : E
h₀ : z₀ ∈ U
hfg : f =ᶠ[𝓝 z₀] g
hfg' : f - g =ᶠ[𝓝 z₀] 0
⊢ EqOn f g U
state_after: no goals

tactic: simp [h]
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
f g : E → F
U : Set E
hf : AnalyticOn 𝕜 f U
hg : AnalyticOn 𝕜 g U
hU : IsPreconnected U
z₀ : E
h₀ : z₀ ∈ U
hfg : f =ᶠ[𝓝 z₀] g
z : E
h : f z = g z
⊢ (f - g) z = 0 z
state_after: no goals
Theorem: KuratowskiEmbedding.embeddingOfSubset_dist_le
File: Mathlib/Topology/MetricSpace/Kuratowski.lean

tactic: refine lp.norm_le_of_forall_le dist_nonneg fun n => ?_
state_before: α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
⊢ dist (embeddingOfSubset x a) (embeddingOfSubset x b) ≤ dist a b
state_after: α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ ‖↑(embeddingOfSubset x a - embeddingOfSubset x b) n‖ ≤ dist a b

tactic: simp only [lp.coeFn_sub, Pi.sub_apply, embeddingOfSubset_coe, Real.dist_eq]
state_before: α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ ‖↑(embeddingOfSubset x a - embeddingOfSubset x b) n‖ ≤ dist a b
state_after: α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ ‖dist a (x n) - dist (x 0) (x n) - (dist b (x n) - dist (x 0) (x n))‖ ≤ dist a b

tactic: convert abs_dist_sub_le a b (x n) using 2
state_before: α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ ‖dist a (x n) - dist (x 0) (x n) - (dist b (x n) - dist (x 0) (x n))‖ ≤ dist a b
state_after: case h.e'_3.h.e'_1
α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ dist a (x n) - dist (x 0) (x n) - (dist b (x n) - dist (x 0) (x n)) = dist a (x n) - dist b (x n)

tactic: ring
state_before: case h.e'_3.h.e'_1
α : Type u
β : Type v
γ : Type w
f g : ↥(lp (fun i => ℝ) ⊤)
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ dist a (x n) - dist (x 0) (x n) - (dist b (x n) - dist (x 0) (x n)) = dist a (x n) - dist b (x n)
state_after: no goals
Theorem: String.data_join
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: rw [join_eq]
state_before: ss : List String
⊢ (join ss).data = (List.map data ss).join
state_after: no goals
Theorem: unitInterval.continuous_qRight
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: fun_prop
state_before: ⊢ Continuous fun p => 2 * ↑p.1
state_after: no goals

tactic: fun_prop
state_before: ⊢ Continuous fun p => 1 + ↑p.2
state_after: no goals
Theorem: Finset.fold_union_inter
File: Mathlib/Data/Finset/Fold.lean

tactic: unfold fold
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (fold op b₁ f (s₁ ∪ s₂)) (fold op b₂ f (s₁ ∩ s₂)) = op (fold op b₂ f s₁) (fold op b₁ f s₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (Multiset.fold op b₁ (Multiset.map f (s₁ ∪ s₂).val)) (Multiset.fold op b₂ (Multiset.map f (s₁ ∩ s₂).val)) =
    op (Multiset.fold op b₂ (Multiset.map f s₁.val)) (Multiset.fold op b₁ (Multiset.map f s₂.val))

tactic: rw [← fold_add op, ← Multiset.map_add, union_val, inter_val, union_add_inter, Multiset.map_add,
  hc.comm, fold_add]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
inst✝ : DecidableEq α
s₁ s₂ : Finset α
b₁ b₂ : β
⊢ op (Multiset.fold op b₁ (Multiset.map f (s₁ ∪ s₂).val)) (Multiset.fold op b₂ (Multiset.map f (s₁ ∩ s₂).val)) =
    op (Multiset.fold op b₂ (Multiset.map f s₁.val)) (Multiset.fold op b₁ (Multiset.map f s₂.val))
state_after: no goals
Theorem: bot_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, symmDiff_bot]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ ⊥ ∆ a = a
state_after: no goals
Theorem: CategoryTheory.NonPreadditiveAbelian.comp_add
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [add_def, comp_sub, neg_def, comp_sub, comp_zero, add_def, neg_def]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
⊢ f ≫ (g + h) = f ≫ g + f ≫ h
state_after: no goals
Theorem: intrinsicFrontier_singleton
File: Mathlib/Analysis/Convex/Intrinsic.lean

tactic: rw [intrinsicFrontier, preimage_coe_affineSpan_singleton, frontier_univ, image_empty]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x✝ x : P
⊢ intrinsicFrontier 𝕜 {x} = ∅
state_after: no goals
Theorem: Filter.EventuallyEq.hasGradientAtFilter_iff
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

tactic: simp [h₁]
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
f₀ f₁ : F → 𝕜
f₀' f₁' x₀ x₁ : F
s₀ s₁ t : Set F
L₀ L₁ : Filter F
h₀ : f₀ =ᶠ[L] f₁
hx : f₀ x = f₁ x
h₁ : f₀' = f₁'
⊢ ∀ (x : F), ((toDual 𝕜 F) f₀') x = ((toDual 𝕜 F) f₁') x
state_after: no goals
Theorem: CategoryTheory.Subgroupoid.mem_full_objs_iff
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

tactic: rw [full_objs]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
D : Set C
c : C
⊢ c ∈ (full D).objs ↔ c ∈ D
state_after: no goals
Theorem: Semiquot.blur_eq_blur'
File: Mathlib/Data/Semiquot.lean

tactic: unfold blur
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
s : Set α
h : q.s ⊆ s
⊢ blur s q = q.blur' h
state_after: α : Type u_1
β : Type u_2
q : Semiquot α
s : Set α
h : q.s ⊆ s
⊢ q.blur' ⋯ = q.blur' h

tactic: congr
state_before: α : Type u_1
β : Type u_2
q : Semiquot α
s : Set α
h : q.s ⊆ s
⊢ q.blur' ⋯ = q.blur' h
state_after: case e_s
α : Type u_1
β : Type u_2
q : Semiquot α
s : Set α
h : q.s ⊆ s
⊢ s ∪ q.s = s

tactic: exact Set.union_eq_self_of_subset_right h
state_before: case e_s
α : Type u_1
β : Type u_2
q : Semiquot α
s : Set α
h : q.s ⊆ s
⊢ s ∪ q.s = s
state_after: no goals
Theorem: MeasureTheory.Measure.pi_closedBall
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [closedBall_pi _ hr, pi_pi]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝³ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝² : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝¹ : ∀ (i : ι), SigmaFinite (μ i)
inst✝ : (i : ι) → MetricSpace (α i)
x : (i : ι) → α i
r : ℝ
hr : 0 ≤ r
⊢ (Measure.pi μ) (Metric.closedBall x r) = ∏ i : ι, (μ i) (Metric.closedBall (x i) r)
state_after: no goals
Theorem: Cardinal.univ_inaccessible
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simpa using lift_lt_univ' ℵ₀
state_before: α : Type u_1
r : α → α → Prop
⊢ ℵ₀ < univ.{u, v}
state_after: no goals

tactic: simp
state_before: α : Type u_1
r : α → α → Prop
⊢ univ.{u, v} ≤ univ.{u, v}.ord.cof
state_after: no goals

tactic: rcases lt_univ'.1 h with ⟨c, rfl⟩
state_before: α : Type u_1
r : α → α → Prop
c : Cardinal.{max (u + 1) v}
h : c < univ.{u, v}
⊢ 2 ^ c < univ.{u, v}
state_after: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ 2 ^ lift.{max (u + 1) v, u} c < univ.{u, v}

tactic: rw [← lift_two_power]
state_before: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ 2 ^ lift.{max (u + 1) v, u} c < univ.{u, v}
state_after: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} (2 ^ c) < univ.{u, v}

tactic: apply lift_lt_univ'
state_before: case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} (2 ^ c) < univ.{u, v}
state_after: no goals