1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Functor.isSplitMono_iff
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: constructor
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
⊢ IsSplitMono (F.map f) ↔ IsSplitMono f
state_after: case mp
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
⊢ IsSplitMono (F.map f) → IsSplitMono f

case mpr
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
⊢ IsSplitMono f → IsSplitMono (F.map f)

tactic: intro h
state_before: case mp
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
⊢ IsSplitMono (F.map f) → IsSplitMono f
state_after: case mp
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
h : IsSplitMono (F.map f)
⊢ IsSplitMono f

tactic: exact IsSplitMono.mk' ((splitMonoEquiv F f).invFun h.exists_splitMono.some)
state_before: case mp
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
h : IsSplitMono (F.map f)
⊢ IsSplitMono f
state_after: no goals

tactic: intro h
state_before: case mpr
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
⊢ IsSplitMono f → IsSplitMono (F.map f)
state_after: case mpr
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
h : IsSplitMono f
⊢ IsSplitMono (F.map f)

tactic: exact IsSplitMono.mk' ((splitMonoEquiv F f).toFun h.exists_splitMono.some)
state_before: case mpr
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 : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : F.Full
inst✝ : F.Faithful
h : IsSplitMono f
⊢ IsSplitMono (F.map f)
state_after: no goals
Theorem: Multiset.count_map
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [Bool.beq_eq_decide_eq, eq_comm, count, countP_map]
state_before: α✝ : Type u_1
β✝ : Type v
γ : Type u_2
inst✝¹ : DecidableEq α✝
s✝ : Multiset α✝
α : Type u_3
β : Type u_4
f : α → β
s : Multiset α
inst✝ : DecidableEq β
b : β
⊢ count b (map f s) = card (filter (fun a => b = f a) s)
state_after: no goals
Theorem: IsCoprime.pow_left_iff
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: refine ⟨fun h ↦ ?_, IsCoprime.pow_left⟩
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
⊢ IsCoprime (x ^ m) y ↔ IsCoprime x y
state_after: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (x ^ m) y
⊢ IsCoprime x y

tactic: rw [← Finset.card_range m, ← Finset.prod_const] at h
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (x ^ m) y
⊢ IsCoprime x y
state_after: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (∏ _x ∈ range m, x) y
⊢ IsCoprime x y

tactic: exact h.of_prod_left 0 (Finset.mem_range.mpr hm)
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (∏ _x ∈ range m, x) y
⊢ IsCoprime x y
state_after: no goals
Theorem: CategoryTheory.Limits.cospanExt_inv_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [cospanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.right = iY.inv
state_after: no goals
Theorem: DFinsupp.zipWith_neLocus_eq_left
File: Mathlib/Data/DFinsupp/NeLocus.lean

tactic: ext a
state_before: α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f : Π₀ (a : α), M a
g₁ g₂ : Π₀ (a : α), N a
hF : ∀ (a : α) (f : M a), Function.Injective fun g => F a f g
⊢ (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) = g₁.neLocus g₂
state_after: case a
α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f : Π₀ (a : α), M a
g₁ g₂ : Π₀ (a : α), N a
hF : ∀ (a : α) (f : M a), Function.Injective fun g => F a f g
a : α
⊢ a ∈ (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) ↔ a ∈ g₁.neLocus g₂

tactic: simpa only [mem_neLocus] using (hF a _).ne_iff
state_before: case a
α : Type u_1
N : α → Type u_2
inst✝⁵ : DecidableEq α
M : α → Type u_3
P : α → Type u_4
inst✝⁴ : (a : α) → Zero (N a)
inst✝³ : (a : α) → Zero (M a)
inst✝² : (a : α) → Zero (P a)
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → DecidableEq (P a)
F : (a : α) → M a → N a → P a
F0 : ∀ (a : α), F a 0 0 = 0
f : Π₀ (a : α), M a
g₁ g₂ : Π₀ (a : α), N a
hF : ∀ (a : α) (f : M a), Function.Injective fun g => F a f g
a : α
⊢ a ∈ (zipWith F F0 f g₁).neLocus (zipWith F F0 f g₂) ↔ a ∈ g₁.neLocus g₂
state_after: no goals
Theorem: Nat.divisorsAntidiagonal_zero
File: Mathlib/NumberTheory/Divisors.lean

tactic: ext
state_before: n : ℕ
⊢ divisorsAntidiagonal 0 = ∅
state_after: case a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ divisorsAntidiagonal 0 ↔ a✝ ∈ ∅

tactic: simp
state_before: case a
n : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ divisorsAntidiagonal 0 ↔ a✝ ∈ ∅
state_after: no goals
Theorem: Batteries.RBNode.find?_some_mem
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [find?]
state_before: α : Type u_1
x : α
cut : α → Ordering
t : RBNode α
⊢ x ∈ find? cut t → x ∈ t
state_after: case node
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → x ∈ l✝
r_ih✝ : x ∈ find? cut r✝ → x ∈ r✝
⊢ (match cut v✝ with
      | Ordering.lt => find? cut l✝
      | Ordering.gt => find? cut r✝
      | Ordering.eq => some v✝) =
      some x →
    x = v✝ ∨ x ∈ l✝ ∨ x ∈ r✝

tactic: split <;> simp (config := {contextual := true}) [*]
state_before: case node
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → x ∈ l✝
r_ih✝ : x ∈ find? cut r✝ → x ∈ r✝
⊢ (match cut v✝ with
      | Ordering.lt => find? cut l✝
      | Ordering.gt => find? cut r✝
      | Ordering.eq => some v✝) =
      some x →
    x = v✝ ∨ x ∈ l✝ ∨ x ∈ r✝
state_after: no goals
Theorem: BoxIntegral.Prepartition.compl_congr
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: dsimp only [compl]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π₁ π₂ : Prepartition I
h : π₁.iUnion = π₂.iUnion
⊢ π₁.compl = π₂.compl
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π₁ π₂ : Prepartition I
h : π₁.iUnion = π₂.iUnion
⊢ ⋯.choose = ⋯.choose

tactic: congr 1
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π₁ π₂ : Prepartition I
h : π₁.iUnion = π₂.iUnion
⊢ ⋯.choose = ⋯.choose
state_after: case e_p
ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π₁ π₂ : Prepartition I
h : π₁.iUnion = π₂.iUnion
⊢ (fun π' => π'.iUnion = ↑I \ π₁.iUnion) = fun π' => π'.iUnion = ↑I \ π₂.iUnion

tactic: rw [h]
state_before: case e_p
ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π₁ π₂ : Prepartition I
h : π₁.iUnion = π₂.iUnion
⊢ (fun π' => π'.iUnion = ↑I \ π₁.iUnion) = fun π' => π'.iUnion = ↑I \ π₂.iUnion
state_after: no goals
Theorem: List.pairwise_of_coe_toFinset_pairwise
File: Mathlib/Data/Finset/Pairwise.lean

tactic: rw [coe_toFinset] at hl
state_before: α : Type u_1
ι : Type u_2
ι' : Type u_3
β : Type u_4
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : (↑l.toFinset).Pairwise r
hn : l.Nodup
⊢ Pairwise r l
state_after: α : Type u_1
ι : Type u_2
ι' : Type u_3
β : Type u_4
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : {a | a ∈ l}.Pairwise r
hn : l.Nodup
⊢ Pairwise r l

tactic: exact hn.pairwise_of_set_pairwise hl
state_before: α : Type u_1
ι : Type u_2
ι' : Type u_3
β : Type u_4
inst✝ : DecidableEq α
r : α → α → Prop
l : List α
hl : {a | a ∈ l}.Pairwise r
hn : l.Nodup
⊢ Pairwise r l
state_after: no goals
Theorem: SimpleGraph.Subgraph.IsMatching.support_eq_verts
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: refine M.support_subset_verts.antisymm fun v hv => ?_
state_before: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
h : M.IsMatching
⊢ M.support = M.verts
state_after: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
h : M.IsMatching
v : V
hv : v ∈ M.verts
⊢ v ∈ M.support

tactic: obtain ⟨w, hvw, -⟩ := h hv
state_before: V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
h : M.IsMatching
v : V
hv : v ∈ M.verts
⊢ v ∈ M.support
state_after: case intro.intro
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
h : M.IsMatching
v : V
hv : v ∈ M.verts
w : V
hvw : M.Adj v w
⊢ v ∈ M.support

tactic: exact ⟨_, hvw⟩
state_before: case intro.intro
V : Type u
G : SimpleGraph V
M✝ M : G.Subgraph
h : M.IsMatching
v : V
hv : v ∈ M.verts
w : V
hvw : M.Adj v w
⊢ v ∈ M.support
state_after: no goals
Theorem: HurwitzZeta.tendsto_hurwitzZeta_sub_one_div_nhds_one
File: Mathlib/NumberTheory/LSeries/HurwitzZeta.lean

tactic: simp only [hurwitzZeta, add_sub_right_comm]
state_before: a : UnitAddCircle
⊢ Tendsto (fun s => hurwitzZeta a s - 1 / (s - 1) / s.Gammaℝ) (𝓝 1) (𝓝 (hurwitzZeta a 1))
state_after: a : UnitAddCircle
⊢ Tendsto (fun s => hurwitzZetaEven a s - 1 / (s - 1) / s.Gammaℝ + hurwitzZetaOdd a s) (𝓝 1)
    (𝓝 (hurwitzZetaEven a 1 + hurwitzZetaOdd a 1))

tactic: refine (tendsto_hurwitzZetaEven_sub_one_div_nhds_one a).add ?_
state_before: a : UnitAddCircle
⊢ Tendsto (fun s => hurwitzZetaEven a s - 1 / (s - 1) / s.Gammaℝ + hurwitzZetaOdd a s) (𝓝 1)
    (𝓝 (hurwitzZetaEven a 1 + hurwitzZetaOdd a 1))
state_after: a : UnitAddCircle
⊢ Tendsto (hurwitzZetaOdd a) (𝓝 1) (𝓝 (hurwitzZetaOdd a 1))

tactic: exact (differentiable_hurwitzZetaOdd a 1).continuousAt.tendsto
state_before: a : UnitAddCircle
⊢ Tendsto (hurwitzZetaOdd a) (𝓝 1) (𝓝 (hurwitzZetaOdd a 1))
state_after: no goals
Theorem: hasProd_subtype_iff_mulIndicator
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [← Set.mulIndicator_range_comp, Subtype.range_coe,
  hasProd_subtype_iff_of_mulSupport_subset Set.mulSupport_mulIndicator_subset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
s : Set β
⊢ HasProd (f ∘ Subtype.val) a ↔ HasProd (s.mulIndicator f) a
state_after: no goals
Theorem: ZMod.χ₈_int_mod_eight
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [← ZMod.intCast_mod n 8, Nat.cast_ofNat]
state_before: n : ℤ
⊢ χ₈ ↑n = χ₈ ↑(n % 8)
state_after: no goals
Theorem: Complex.abs_ofReal
File: Mathlib/Data/Complex/Abs.lean

tactic: simp [Complex.abs, normSq_ofReal, Real.sqrt_mul_self_eq_abs]
state_before: r : ℝ
⊢ abs ↑r = |r|
state_after: no goals
Theorem: MeasureTheory.Integrable.condDistrib_ae_map
File: Mathlib/Probability/Kernel/CondDistrib.lean

tactic: rw [condDistrib, ← Measure.fst_map_prod_mk₀ (X := X) hY]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ ∀ᵐ (b : β) ∂Measure.map X μ, Integrable (fun ω => f (b, ω)) ((condDistrib Y X μ) b)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ ∀ᵐ (b : β) ∂(Measure.map (fun a => (X a, Y a)) μ).fst,
    Integrable (fun ω => f (b, ω)) ((Measure.map (fun a => (X a, Y a)) μ).condKernel b)

tactic: exact hf_int.condKernel_ae
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
hY : AEMeasurable Y μ
hf_int : Integrable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ ∀ᵐ (b : β) ∂(Measure.map (fun a => (X a, Y a)) μ).fst,
    Integrable (fun ω => f (b, ω)) ((Measure.map (fun a => (X a, Y a)) μ).condKernel b)
state_after: no goals
Theorem: HasFPowerSeriesOnBall.congr
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: convert hf.hasSum hy using 1
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hg : EqOn f g (EMetric.ball x r)
y : E
hy : y ∈ EMetric.ball 0 r
⊢ HasSum (fun n => (p n) fun x => y) (g (x + y))
state_after: case h.e'_6
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hg : EqOn f g (EMetric.ball x r)
y : E
hy : y ∈ EMetric.ball 0 r
⊢ g (x + y) = f (x + y)

tactic: apply hg.symm
state_before: case h.e'_6
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hg : EqOn f g (EMetric.ball x r)
y : E
hy : y ∈ EMetric.ball 0 r
⊢ g (x + y) = f (x + y)
state_after: case h.e'_6.a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hg : EqOn f g (EMetric.ball x r)
y : E
hy : y ∈ EMetric.ball 0 r
⊢ x + y ∈ EMetric.ball x r

tactic: simpa [edist_eq_coe_nnnorm_sub] using hy
state_before: case h.e'_6.a
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hg : EqOn f g (EMetric.ball x r)
y : E
hy : y ∈ EMetric.ball 0 r
⊢ x + y ∈ EMetric.ball x r
state_after: no goals
Theorem: Basis.dualBasis_equivFun
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [Basis.equivFun_apply, dualBasis_repr]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
l : Dual R M
i : ι
⊢ b.dualBasis.equivFun l i = l (b i)
state_after: no goals
Theorem: same_add_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← div_self h, add_div]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionSemiring α
a b c d : α
h : b ≠ 0
⊢ (b + a) / b = 1 + a / b
state_after: no goals
Theorem: MonoidHom.range_eq_top_of_cancel
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

tactic: specialize h 1 (QuotientGroup.mk' _) _
state_before: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
⊢ f.range = ⊤
state_after: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
⊢ comp 1 f = (QuotientGroup.mk' f.range).comp f

A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : 1 = QuotientGroup.mk' f.range
⊢ f.range = ⊤

tactic: replace h : (QuotientGroup.mk' f.range).ker = (1 : B →* B ⧸ f.range).ker := by rw [h]
state_before: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : 1 = QuotientGroup.mk' f.range
⊢ f.range = ⊤
state_after: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : (QuotientGroup.mk' f.range).ker = ker 1
⊢ f.range = ⊤

tactic: rwa [ker_one, QuotientGroup.ker_mk'] at h
state_before: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : (QuotientGroup.mk' f.range).ker = ker 1
⊢ f.range = ⊤
state_after: no goals

tactic: ext1 x
state_before: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
⊢ comp 1 f = (QuotientGroup.mk' f.range).comp f
state_after: case h
A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
x : A
⊢ (comp 1 f) x = ((QuotientGroup.mk' f.range).comp f) x

tactic: simp only [one_apply, coe_comp, coe_mk', Function.comp_apply]
state_before: case h
A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
x : A
⊢ (comp 1 f) x = ((QuotientGroup.mk' f.range).comp f) x
state_after: case h
A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
x : A
⊢ 1 = ↑(f x)

tactic: rw [show (1 : B ⧸ f.range) = (1 : B) from QuotientGroup.mk_one _, QuotientGroup.eq, inv_one,
  one_mul]
state_before: case h
A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
x : A
⊢ 1 = ↑(f x)
state_after: case h
A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
x : A
⊢ f x ∈ f.range

tactic: exact ⟨x, rfl⟩
state_before: case h
A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : ∀ (u v : B →* B ⧸ f.range), u.comp f = v.comp f → u = v
x : A
⊢ f x ∈ f.range
state_after: no goals

tactic: rw [h]
state_before: A : Type u
B : Type v
inst✝¹ : CommGroup A
inst✝ : CommGroup B
f : A →* B
h : 1 = QuotientGroup.mk' f.range
⊢ (QuotientGroup.mk' f.range).ker = ker 1
state_after: no goals
Theorem: Finsupp.mapDomain_comapDomain
File: Mathlib/Data/Finsupp/Basic.lean

tactic: conv_rhs => rw [← embDomain_comapDomain (f := ⟨f, hf⟩) hl (M := M), embDomain_eq_mapDomain]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
f : α → β
hf : Injective f
l : β →₀ M
hl : ↑l.support ⊆ Set.range f
⊢ mapDomain f (comapDomain f l ⋯) = l
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
f : α → β
hf : Injective f
l : β →₀ M
hl : ↑l.support ⊆ Set.range f
⊢ mapDomain f (comapDomain f l ⋯) =
    mapDomain (⇑{ toFun := f, inj' := hf }) (comapDomain (⇑{ toFun := f, inj' := hf }) l ⋯)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
f : α → β
hf : Injective f
l : β →₀ M
hl : ↑l.support ⊆ Set.range f
⊢ mapDomain f (comapDomain f l ⋯) =
    mapDomain (⇑{ toFun := f, inj' := hf }) (comapDomain (⇑{ toFun := f, inj' := hf }) l ⋯)
state_after: no goals
Theorem: QuaternionAlgebra.Basis.lift_add
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: simp only [lift, add_re, map_add, add_imI, add_smul, add_imJ, add_imK]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
x y : ℍ[R,c₁,c₂]
⊢ q.lift (x + y) = q.lift x + q.lift y
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
x y : ℍ[R,c₁,c₂]
⊢ (algebraMap R A) x.re + (algebraMap R A) y.re + (x.imI • q.i + y.imI • q.i) + (x.imJ • q.j + y.imJ • q.j) +
      (x.imK • q.k + y.imK • q.k) =
    (algebraMap R A) x.re + x.imI • q.i + x.imJ • q.j + x.imK • q.k +
      ((algebraMap R A) y.re + y.imI • q.i + y.imJ • q.j + y.imK • q.k)

tactic: abel
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
x y : ℍ[R,c₁,c₂]
⊢ (algebraMap R A) x.re + (algebraMap R A) y.re + (x.imI • q.i + y.imI • q.i) + (x.imJ • q.j + y.imJ • q.j) +
      (x.imK • q.k + y.imK • q.k) =
    (algebraMap R A) x.re + x.imI • q.i + x.imJ • q.j + x.imK • q.k +
      ((algebraMap R A) y.re + y.imI • q.i + y.imJ • q.j + y.imK • q.k)
state_after: no goals
Theorem: Set.restrict_extend_compl_range
File: Mathlib/Data/Set/Function.lean

tactic: classical
exact restrict_dite_compl _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
f : α → β
g : α → γ
g' : β → γ
⊢ (range f)ᶜ.restrict (extend f g g') = g' ∘ Subtype.val
state_after: no goals

tactic: exact restrict_dite_compl _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
f : α → β
g : α → γ
g' : β → γ
⊢ (range f)ᶜ.restrict (extend f g g') = g' ∘ Subtype.val
state_after: no goals
Theorem: sq_add_sq_mul_sq_add_sq
File: Mathlib/Algebra/Ring/Identities.lean

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R
⊢ (x₁ ^ 2 + x₂ ^ 2) * (y₁ ^ 2 + y₂ ^ 2) = (x₁ * y₁ - x₂ * y₂) ^ 2 + (x₁ * y₂ + x₂ * y₁) ^ 2
state_after: no goals
Theorem: Subgroup.relindex_top_right
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← relindex_mul_index (show H ≤ ⊤ from le_top), index_top, mul_one]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ H.relindex ⊤ = H.index
state_after: no goals
Theorem: SetTheory.PGame.Subsequent.moveRight_mk_right
File: Mathlib/SetTheory/Game/PGame.lean

tactic: pgame_wf_tac
state_before: xl xr : Type u
xL : xl → PGame
i : xr
xR : xr → PGame
j : (xR i).RightMoves
⊢ ((xR i).moveRight j).Subsequent (mk xl xr xL xR)
state_after: no goals