tasksource/leandojo huggingface dataset:
Theorem: Set.range_extend_subset
File: Mathlib/Data/Set/Function.lean

tactic: classical
rintro _ ⟨y, rfl⟩
rw [extend_def]
split_ifs with h
exacts [Or.inl (mem_range_self _), Or.inr (mem_image_of_mem _ h)]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.4057
π : α → Type ?u.4062
f : α → β
g : α → γ
g' : β → γ
⊢ range (extend f g g') ⊆ range g ∪ g' '' range fᶜ

tactic: rintro _ ⟨y, rfl⟩
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.4057
π : α → Type ?u.4062
f : α → β
g : α → γ
g' : β → γ
⊢ range (extend f g g') ⊆ range g ∪ g' '' range fᶜ

tactic: rw [extend_def]
state_before: case intro
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.4057
π : α → Type ?u.4062
f : α → β
g : α → γ
g' : β → γ
y : β
⊢ extend f g g' y ∈ range g ∪ g' '' range fᶜ

tactic: split_ifs with h
state_before: case intro
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.4057
π : α → Type ?u.4062
f : α → β
g : α → γ
g' : β → γ
y : β
⊢ (if h : ∃ a, f a = y then g (Classical.choose h) else g' y) ∈ range g ∪ g' '' range fᶜ

tactic: exacts [Or.inl (mem_range_self _), Or.inr (mem_image_of_mem _ h)]
state_before: case intro.inl
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.4057
π : α → Type ?u.4062
f : α → β
g : α → γ
g' : β → γ
y : β
h : ∃ a, f a = y
⊢ g (Classical.choose h) ∈ range g ∪ g' '' range fᶜ

case intro.inr
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.4057
π : α → Type ?u.4062
f : α → β
g : α → γ
g' : β → γ
y : β
h : ¬∃ a, f a = y
⊢ g' y ∈ range g ∪ g' '' range fᶜ
Theorem: inv_mul_lt_one_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_one]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ b < a * 1 ↔ b < a
Theorem: affineSegment_comm
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine' Set.ext fun z => _
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.8362
P : Type u_1
P' : Type ?u.8368
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
⊢ affineSegment R x y = affineSegment R y x

tactic: rintro ⟨t, ht, hxy⟩
state_before: case mpr
R : Type u_2
V : Type u_3
V' : Type ?u.8362
P : Type u_1
P' : Type ?u.8368
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
⊢ z ∈ affineSegment R y x → z ∈ affineSegment R x y

tactic: refine' ⟨1 - t, _, _⟩
state_before: case mpr.intro.intro
R : Type u_2
V : Type u_3
V' : Type ?u.8362
P : Type u_1
P' : Type ?u.8368
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
t : R
ht : t ∈ Set.Icc 0 1
hxy : ↑(lineMap y x) t = z
⊢ z ∈ affineSegment R x y

tactic: rwa [Set.sub_mem_Icc_iff_right, sub_self, sub_zero]
state_before: case mpr.intro.intro.refine'_1
R : Type u_2
V : Type u_3
V' : Type ?u.8362
P : Type u_1
P' : Type ?u.8368
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
t : R
ht : t ∈ Set.Icc 0 1
hxy : ↑(lineMap y x) t = z
⊢ 1 - t ∈ Set.Icc 0 1

tactic: rwa [lineMap_apply_one_sub]
state_before: case mpr.intro.intro.refine'_2
R : Type u_2
V : Type u_3
V' : Type ?u.8362
P : Type u_1
P' : Type ?u.8368
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
t : R
ht : t ∈ Set.Icc 0 1
hxy : ↑(lineMap y x) t = z
⊢ ↑(lineMap x y) (1 - t) = z
Theorem: Nat.zero_lt_of_ne_zero
File: src/lean/Init/Data/Nat/Basic.lean

tactic: match a with
| 0 => contradiction
| a+1 => apply Nat.zero_lt_succ
state_before: a : Nat
h : a ≠ 0
⊢ 0 < a

tactic: contradiction
state_before: a : Nat
h : 0 ≠ 0
⊢ 0 < 0

tactic: apply Nat.zero_lt_succ
state_before: a✝ a : Nat
h : a + 1 ≠ 0
⊢ 0 < a + 1
Theorem: Finsupp.total_fin_zero
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: ext i
state_before: α : Type ?u.435535
M : Type u_1
N : Type ?u.435541
P : Type ?u.435544
R : Type u_2
S : Type ?u.435550
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type ?u.435642
M' : Type ?u.435645
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : Fin 0 → M
⊢ Finsupp.total (Fin 0) M R f = 0

tactic: apply finZeroElim i
state_before: case h.h
α : Type ?u.435535
M : Type u_1
N : Type ?u.435541
P : Type ?u.435544
R : Type u_2
S : Type ?u.435550
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type ?u.435642
M' : Type ?u.435645
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : Fin 0 → M
i : Fin 0
⊢ ↑(comp (Finsupp.total (Fin 0) M R f) (lsingle i)) 1 = ↑(comp 0 (lsingle i)) 1
Theorem: inner_map_polarization'
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [map_add, map_sub, inner_add_left, inner_add_right, LinearMap.map_smul, inner_smul_left,
  inner_smul_right, Complex.conj_I, ← pow_two, Complex.I_sq, inner_sub_left, inner_sub_right,
  mul_add, ← mul_assoc, mul_neg, neg_neg, sub_neg_eq_add, one_mul, neg_one_mul, mul_sub, sub_sub]
state_before: 𝕜 : Type ?u.2732526
E : Type ?u.2732529
F : Type ?u.2732532
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
x y : V
⊢ inner (↑T x) y =
    (inner (↑T (x + y)) (x + y) - inner (↑T (x - y)) (x - y) -
          Complex.I * inner (↑T (x + Complex.I • y)) (x + Complex.I • y) +
        Complex.I * inner (↑T (x - Complex.I • y)) (x - Complex.I • y)) /
      4

tactic: ring
state_before: 𝕜 : Type ?u.2732526
E : Type ?u.2732529
F : Type ?u.2732532
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
x y : V
⊢ inner (↑T x) y =
    (inner (↑T x) x + inner (↑T y) x + (inner (↑T x) y + inner (↑T y) y) -
          (inner (↑T x) x - (inner (↑T y) x + (inner (↑T x) y - inner (↑T y) y)) +
            (Complex.I * inner (↑T x) x + inner (↑T y) x + (-inner (↑T x) y + Complex.I * inner (↑T y) y))) +
        (Complex.I * inner (↑T x) x - (inner (↑T y) x + (-inner (↑T x) y - Complex.I * inner (↑T y) y)))) /
      4
Theorem: Units.mul_inv_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← h, inv_mul_cancel_right]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c✝ u : αˣ
a c : α
h : a * ↑b⁻¹ = c
⊢ a = c * ↑b

tactic: rw [h, mul_inv_cancel_right]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c✝ u : αˣ
a c : α
h : a = c * ↑b
⊢ a * ↑b⁻¹ = c
Theorem: Fin.add_one_le_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n✝ m n : ℕ
k : Fin (n + 1)
⊢ k + 1 ≤ k ↔ k = last n

tactic: rw [← not_iff_not, ← add_one_lt_iff, lt_iff_le_and_ne, not_and']
state_before: case succ
n m n✝ : ℕ
k : Fin (Nat.succ n✝ + 1)
⊢ k + 1 ≤ k ↔ k = last (Nat.succ n✝)

tactic: refine' ⟨fun h _ => h, fun h => h _⟩
state_before: case succ
n m n✝ : ℕ
k : Fin (Nat.succ n✝ + 1)
⊢ ¬k + 1 ≤ k ↔ k + 1 ≠ k → ¬k + 1 ≤ k

tactic: rw [Ne.def, ext_iff, val_add_one]
state_before: case succ
n m n✝ : ℕ
k : Fin (Nat.succ n✝ + 1)
h : k + 1 ≠ k → ¬k + 1 ≤ k
⊢ k + 1 ≠ k

tactic: split_ifs with hk <;> simp [hk, @eq_comm ℕ 0]
state_before: case succ
n m n✝ : ℕ
k : Fin (Nat.succ n✝ + 1)
h : k + 1 ≠ k → ¬k + 1 ≤ k
⊢ ¬(if k = last (n✝ + 1) then 0 else ↑k + 1) = ↑k

tactic: haveI : Subsingleton (Fin (0 + 1)) := by
  convert_to Subsingleton (Fin 1)
  infer_instance
state_before: case zero
n m : ℕ
k : Fin (zero + 1)
⊢ k + 1 ≤ k ↔ k = last zero

tactic: simp [Subsingleton.elim (k + 1) k, Subsingleton.elim (Fin.last _) k]
state_before: case zero
n m : ℕ
k : Fin (zero + 1)
this : Subsingleton (Fin (0 + 1))
⊢ k + 1 ≤ k ↔ k = last zero

tactic: convert_to Subsingleton (Fin 1)
state_before: n m : ℕ
k : Fin (zero + 1)
⊢ Subsingleton (Fin (0 + 1))

tactic: infer_instance
state_before: n m : ℕ
k : Fin (zero + 1)
⊢ Subsingleton (Fin 1)
Theorem: Matrix.compl_apply_diag
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [compl]
state_before: V : Type u_2
α : Type u_1
β : Type ?u.12260
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
i : V
⊢ compl A i i = 0
Theorem: SimplicialObject.Splitting.ι_πSummand_eq_id
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: dsimp [ιSummand, πSummand]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ιSummand s A ≫ πSummand s A = 𝟙 (N s (SimplexCategory.len A.fst.unop))

tactic: simp only [summand, assoc, IsIso.hom_inv_id_assoc]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ((ιCoprod s.N A ≫ map X s.ι Δ) ≫
      inv (map X s.ι Δ) ≫
        Sigma.desc fun B =>
          if h : B = A then eqToHom (_ : summand s.N Δ B = N s (SimplexCategory.len A.fst.unop)) else 0) =
    𝟙 (N s (SimplexCategory.len A.fst.unop))

tactic: erw [colimit.ι_desc, Cofan.mk_ι_app]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (ιCoprod s.N A ≫
      Sigma.desc fun B =>
        if h : B = A then eqToHom (_ : summand s.N Δ B = N s (SimplexCategory.len A.fst.unop)) else 0) =
    𝟙 (N s (SimplexCategory.len A.fst.unop))

tactic: dsimp
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (if h : { as := A }.as = A then eqToHom (_ : summand s.N Δ { as := A }.as = N s (SimplexCategory.len A.fst.unop))
    else 0) =
    𝟙 (N s (SimplexCategory.len A.fst.unop))

tactic: simp only [dite_eq_ite, ite_true]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (if h : A = A then 𝟙 (N s (SimplexCategory.len A.fst.unop)) else 0) = 𝟙 (N s (SimplexCategory.len A.fst.unop))
Theorem: skewAdjoint.I_smul_neg_I
File: Mathlib/Data/Complex/Module.lean

tactic: simp only [smul_smul, skewAdjoint.negISMul_apply_coe, neg_smul, smul_neg, I_mul_I, one_smul,
  neg_neg]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : { x // x ∈ skewAdjoint A }
⊢ I • ↑(↑negISMul a) = ↑a
Theorem: Asymptotics.isEquivalent_iff_tendsto_one
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
⊢ u ~[l] v ↔ Tendsto (u / v) l (𝓝 1)

tactic: intro hequiv
state_before: case mp
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
⊢ u ~[l] v → Tendsto (u / v) l (𝓝 1)

tactic: have := hequiv.isLittleO.tendsto_div_nhds_zero
state_before: case mp
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
hequiv : u ~[l] v
⊢ Tendsto (u / v) l (𝓝 1)

tactic: simp only [Pi.sub_apply, sub_div] at this
state_before: case mp
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
hequiv : u ~[l] v
this : Tendsto (fun x => (u - v) x / v x) l (𝓝 0)
⊢ Tendsto (u / v) l (𝓝 1)

tactic: have key : Tendsto (fun x ↦ v x / v x) l (𝓝 1) :=
  (tendsto_congr' <| hz.mono fun x hnz ↦ @div_self _ _ (v x) hnz).mpr tendsto_const_nhds
state_before: case mp
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
hequiv : u ~[l] v
this : Tendsto (fun x => u x / v x - v x / v x) l (𝓝 0)
⊢ Tendsto (u / v) l (𝓝 1)

tactic: convert this.add key
state_before: case mp
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
hequiv : u ~[l] v
this : Tendsto (fun x => u x / v x - v x / v x) l (𝓝 0)
key : Tendsto (fun x => v x / v x) l (𝓝 1)
⊢ Tendsto (u / v) l (𝓝 1)

tactic: simp
state_before: case h.e'_3.h
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
hequiv : u ~[l] v
this : Tendsto (fun x => u x / v x - v x / v x) l (𝓝 0)
key : Tendsto (fun x => v x / v x) l (𝓝 1)
x✝ : α
⊢ (u / v) x✝ = u x✝ / v x✝ - v x✝ / v x✝ + v x✝ / v x✝

tactic: norm_num
state_before: case h.e'_5.h.e'_3
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
hequiv : u ~[l] v
this : Tendsto (fun x => u x / v x - v x / v x) l (𝓝 0)
key : Tendsto (fun x => v x / v x) l (𝓝 1)
⊢ 1 = 0 + 1

tactic: exact isEquivalent_of_tendsto_one (hz.mono fun x hnvz hz ↦ (hnvz hz).elim)
state_before: case mpr
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
hz : ∀ᶠ (x : α) in l, v x ≠ 0
⊢ Tendsto (u / v) l (𝓝 1) → u ~[l] v
Theorem: Basis.ofEquivFun_equivFun
File: Mathlib/LinearAlgebra/Basis.lean

tactic: classical
  ext j
  simp only [Basis.equivFun_symm_apply, Basis.coe_ofEquivFun]
  simp_rw [Function.update_apply, ite_smul]
  simp only [Finset.mem_univ, if_true, Pi.zero_apply, one_smul, Finset.sum_ite_eq', zero_smul]
state_before: ι : Type u_1
ι' : Type ?u.694515
R : Type u_2
R₂ : Type ?u.694521
K : Type ?u.694524
M : Type u_3
M' : Type ?u.694530
M'' : Type ?u.694533
V : Type u
V' : Type ?u.694538
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b v : Basis ι R M
⊢ ofEquivFun (equivFun v) = v

tactic: ext j
state_before: ι : Type u_1
ι' : Type ?u.694515
R : Type u_2
R₂ : Type ?u.694521
K : Type ?u.694524
M : Type u_3
M' : Type ?u.694530
M'' : Type ?u.694533
V : Type u
V' : Type ?u.694538
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b v : Basis ι R M
⊢ ofEquivFun (equivFun v) = v

tactic: simp only [Basis.equivFun_symm_apply, Basis.coe_ofEquivFun]
state_before: case a
ι : Type u_1
ι' : Type ?u.694515
R : Type u_2
R₂ : Type ?u.694521
K : Type ?u.694524
M : Type u_3
M' : Type ?u.694530
M'' : Type ?u.694533
V : Type u
V' : Type ?u.694538
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b v : Basis ι R M
j : ι
⊢ ↑(ofEquivFun (equivFun v)) j = ↑v j

tactic: simp_rw [Function.update_apply, ite_smul]
state_before: case a
ι : Type u_1
ι' : Type ?u.694515
R : Type u_2
R₂ : Type ?u.694521
K : Type ?u.694524
M : Type u_3
M' : Type ?u.694530
M'' : Type ?u.694533
V : Type u
V' : Type ?u.694538
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b v : Basis ι R M
j : ι
⊢ ∑ x : ι, update 0 j 1 x • ↑v x = ↑v j

tactic: simp only [Finset.mem_univ, if_true, Pi.zero_apply, one_smul, Finset.sum_ite_eq', zero_smul]
state_before: case a
ι : Type u_1
ι' : Type ?u.694515
R : Type u_2
R₂ : Type ?u.694521
K : Type ?u.694524
M : Type u_3
M' : Type ?u.694530
M'' : Type ?u.694533
V : Type u
V' : Type ?u.694538
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b v : Basis ι R M
j : ι
⊢ (∑ x : ι, if x = j then 1 • ↑v x else OfNat.ofNat 0 x • ↑v x) = ↑v j
Theorem: DirectSum.fromAddMonoid_of
File: Mathlib/Algebra/DirectSum/Basic.lean

tactic: rw [fromAddMonoid, toAddMonoid_of]
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝ : AddCommMonoid γ
i : ι
f : γ →+ β i
⊢ ↑fromAddMonoid (↑(of (fun i => γ →+ β i) i) f) = AddMonoidHom.comp (of β i) f

tactic: rfl
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
γ : Type u₁
inst✝ : AddCommMonoid γ
i : ι
f : γ →+ β i
⊢ ↑(↑AddMonoidHom.compHom (of β i)) f = AddMonoidHom.comp (of β i) f
Theorem: aemeasurable_of_re_im
File: Mathlib/MeasureTheory/Function/SpecialFunctions/IsROrC.lean

tactic: convert AEMeasurable.add (M := 𝕜) (IsROrC.measurable_ofReal.comp_aemeasurable hre)
    ((IsROrC.measurable_ofReal.comp_aemeasurable him).mul_const IsROrC.I)
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : AEMeasurable fun x => ↑IsROrC.re (f x)
him : AEMeasurable fun x => ↑IsROrC.im (f x)
⊢ AEMeasurable f

tactic: exact (IsROrC.re_add_im _).symm
state_before: case h.e'_5.h
α : Type u_1
𝕜 : Type u_2
inst✝¹ : IsROrC 𝕜
inst✝ : MeasurableSpace α
f : α → 𝕜
μ : MeasureTheory.Measure α
hre : AEMeasurable fun x => ↑IsROrC.re (f x)
him : AEMeasurable fun x => ↑IsROrC.im (f x)
x✝ : α
⊢ f x✝ = (IsROrC.ofReal ∘ fun x => ↑IsROrC.re (f x)) x✝ + (IsROrC.ofReal ∘ fun x => ↑IsROrC.im (f x)) x✝ * IsROrC.I
Theorem: Computation.liftRel_pure_left
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [eq_of_pure_mem ma']
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ pure a
⊢ ∃ b, b ∈ cb ∧ R a' b

tactic: exact ⟨b, mb, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ pure a
⊢ ∃ b, b ∈ cb ∧ R a b

tactic: rw [mem_unique mb' mb]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ R a b'

tactic: exact ab
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ R a b
Theorem: CategoryTheory.Arrow.square_from_iso_invert
File: Mathlib/CategoryTheory/Arrow.lean

tactic: simp only [Iso.inv_hom_id_assoc, Arrow.w, Arrow.mk_hom]
state_before: T : Type u
inst✝ : Category T
X Y : T
i : X ≅ Y
p : Arrow T
sq : mk i.hom ⟶ p
⊢ i.inv ≫ sq.left ≫ p.hom = sq.right
Theorem: Std.AssocList.contains_eq
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [*, contains]
state_before: α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
l : AssocList α β
⊢ contains a l = List.any (toList l) fun x => x.fst == a
Theorem: IsClosed.frontier_eq
File: Mathlib/Topology/Basic.lean

tactic: rw [frontier, hs.closure_eq]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
hs : IsClosed s
⊢ frontier s = s \ interior s
Theorem: Metric.continuousOn_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [ContinuousOn, continuousWithinAt_iff]
state_before: α : Type u
β : Type v
X : Type ?u.101995
ι : Type ?u.101998
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : PseudoMetricSpace β
f : α → β
s : Set α
⊢ ContinuousOn f s ↔
    ∀ (b : α), b ∈ s → ∀ (ε : ℝ), ε > 0 → ∃ δ, δ > 0 ∧ ∀ (a : α), a ∈ s → dist a b < δ → dist (f a) (f b) < ε
Theorem: Stream'.mem_of_mem_odd
File: Mathlib/Data/Stream/Init.lean

tactic: rw [h, nth_odd]
state_before: α : Type u
β : Type v
δ : Type w
a : α
s : Stream' α
x✝ : a ∈ odd s
n : ℕ
h : (fun b => a = b) (nth (odd s) n)
⊢ (fun b => a = b) (nth s (2 * n + 1))
Theorem: CauSeq.exists_gt
File: Mathlib/Data/Real/CauSeq.lean

tactic: rw [sub_apply, const_apply, le_sub_iff_add_le', add_le_add_iff_right]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f : CauSeq α abs
K : α
H : ∀ (i : ℕ), abs (↑f i) < K
i : ℕ
x✝ : i ≥ 0
⊢ 1 ≤ ↑(const (K + 1) - f) i

tactic: exact le_of_lt (abs_lt.1 (H _)).2
state_before: α : Type u_1
inst✝ : LinearOrderedField α
f : CauSeq α abs
K : α
H : ∀ (i : ℕ), abs (↑f i) < K
i : ℕ
x✝ : i ≥ 0
⊢ ↑f i ≤ K
Theorem: Turing.Tape.move_right_left
File: Mathlib/Computability/TuringMachine.lean

tactic: cases T
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ move Dir.left (move Dir.right T) = T

tactic: simp [Tape.move]
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.left (move Dir.right { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
Theorem: accPt_iff_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp [acc_principal_iff_cluster, clusterPt_principal_iff, Set.Nonempty, exists_prop, and_assoc,
  @and_comm (¬_ = x)]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
x : α
C : Set α
⊢ AccPt x (𝓟 C) ↔ ∀ (U : Set α), U ∈ 𝓝 x → ∃ y, y ∈ U ∩ C ∧ y ≠ x
Theorem: heq_rec_iff_heq
File: Mathlib/Logic/Basic.lean

tactic: subst e
state_before: α : Sort u_1
β : Sort u_2
a b : α
C : α → Sort u_2
x : β
y : C a
e : a = b
⊢ HEq x (e ▸ y) ↔ HEq x y

tactic: rfl
state_before: α : Sort u_1
β : Sort u_2
a : α
C : α → Sort u_2
x : β
y : C a
⊢ HEq x ((_ : a = a) ▸ y) ↔ HEq x y
Theorem: ENNReal.hasSum_toReal
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift f to α → ℝ≥0 using ENNReal.ne_top_of_tsum_ne_top hsum
state_before: α : Type u_1
β : Type ?u.307697
γ : Type ?u.307700
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0∞
hsum : (∑' (x : α), f x) ≠ ⊤
⊢ HasSum (fun x => ENNReal.toReal (f x)) (∑' (x : α), ENNReal.toReal (f x))

tactic: simp only [coe_toReal, ← NNReal.coe_tsum, NNReal.hasSum_coe]
state_before: case intro
α : Type u_1
β : Type ?u.307697
γ : Type ?u.307700
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
hsum : (∑' (x : α), (fun i => ↑(f i)) x) ≠ ⊤
⊢ HasSum (fun x => ENNReal.toReal ((fun i => ↑(f i)) x)) (∑' (x : α), ENNReal.toReal ((fun i => ↑(f i)) x))

tactic: exact (tsum_coe_ne_top_iff_summable.1 hsum).hasSum
state_before: case intro
α : Type u_1
β : Type ?u.307697
γ : Type ?u.307700
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
hsum : (∑' (x : α), (fun i => ↑(f i)) x) ≠ ⊤
⊢ HasSum (fun a => f a) (∑' (a : α), f a)
Theorem: SimpleGraph.card_commonNeighbors_le_degree_left
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [← card_neighborSet_eq_degree]
state_before: ι : Sort ?u.297010
𝕜 : Type ?u.297013
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v w : V
⊢ Fintype.card ↑(commonNeighbors G v w) ≤ degree G v

tactic: exact Set.card_le_of_subset (Set.inter_subset_left _ _)
state_before: ι : Sort ?u.297010
𝕜 : Type ?u.297013
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v w : V
⊢ Fintype.card ↑(commonNeighbors G v w) ≤ Fintype.card ↑(neighborSet G v)
Theorem: List.concat_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.24771
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
⊢ concat l a ≠ []
Theorem: UpperSet.compl_iSup₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [UpperSet.compl_iSup]
state_before: α : Type u_1
β : Type ?u.85112
γ : Type ?u.85115
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : LE α
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ compl (⨆ (i : ι) (j : κ i), f i j) = ⨆ (i : ι) (j : κ i), compl (f i j)