tasksource/leandojo huggingface dataset:
Theorem: Ordinal.add_mul_limit_aux
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: apply (mul_le_mul_left' (le_succ c') _).trans
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ (a + b) * c' ≤ a * c

tactic: rw [IH _ h]
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ (a + b) * succ c' ≤ a * c

tactic: apply (add_le_add_left _ _).trans
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ a * succ c' + b ≤ a * c

tactic: rw [← mul_succ]
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ a * succ c' + ?m.427842 ≤ a * c

tactic: exact mul_le_mul_left' (succ_le_of_lt <| l.2 _ h) _
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ a * succ (succ c') ≤ a * c

tactic: rw [← ba]
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ b ≤ a

tactic: exact le_add_right _ _
state_before: a b c : Ordinal
ba : b + a = a
l : IsLimit c
IH : ∀ (c' : Ordinal), c' < c → (a + b) * succ c' = a * succ c' + b
c' : Ordinal
h : c' < c
⊢ b ≤ b + a
Theorem: Turing.tr_reaches
File: Mathlib/Computability/TuringMachine.lean

tactic: rcases reflTransGen_iff_eq_or_transGen.1 ab with (rfl | ab)
state_before: σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab : Reaches f₁ a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

tactic: exact ⟨_, aa, ReflTransGen.refl⟩
state_before: case inl
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₂ : σ₂
b₁ : σ₁
aa : tr b₁ a₂
ab : Reaches f₁ b₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

tactic: have ⟨b₂, bb, h⟩ := tr_reaches₁ H aa ab
state_before: case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

tactic: exact ⟨b₂, bb, h.to_reflTransGen⟩
state_before: case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
b₂ : σ₂
bb : tr b₁ b₂
h : Reaches₁ f₂ a₂ b₂
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
Theorem: Polynomial.natDegree_primPart
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: by_cases h : C p.content = 0
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ natDegree (primPart p) = natDegree p

tactic: conv_rhs =>
  rw [p.eq_C_content_mul_primPart, natDegree_mul h p.primPart_ne_zero, natDegree_C, zero_add]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ¬↑C (content p) = 0
⊢ natDegree (primPart p) = natDegree p

tactic: rw [C_eq_zero, content_eq_zero_iff] at h
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ↑C (content p) = 0
⊢ natDegree (primPart p) = natDegree p

tactic: simp [h]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : p = 0
⊢ natDegree (primPart p) = natDegree p
Theorem: CategoryTheory.transferNatTransSelf_symm_of_iso
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: suffices IsIso ((transferNatTransSelf adj₁ adj₂) ((transferNatTransSelf adj₁ adj₂).symm f))
  by simpa using this
state_before: C : Type u₁
D : Type u₂
inst✝² : Category C
inst✝¹ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₁ ⟶ R₂
inst✝ : IsIso (↑(transferNatTransSelf adj₁ adj₂).symm f)
⊢ IsIso f

tactic: infer_instance
state_before: C : Type u₁
D : Type u₂
inst✝² : Category C
inst✝¹ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₁ ⟶ R₂
inst✝ : IsIso (↑(transferNatTransSelf adj₁ adj₂).symm f)
⊢ IsIso (↑(transferNatTransSelf adj₁ adj₂) (↑(transferNatTransSelf adj₁ adj₂).symm f))

tactic: simpa using this
state_before: C : Type u₁
D : Type u₂
inst✝² : Category C
inst✝¹ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
f : R₁ ⟶ R₂
inst✝ : IsIso (↑(transferNatTransSelf adj₁ adj₂).symm f)
this : IsIso (↑(transferNatTransSelf adj₁ adj₂) (↑(transferNatTransSelf adj₁ adj₂).symm f))
⊢ IsIso f
Theorem: GeneralizedContinuedFraction.squashSeq_nth_of_not_terminated
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: simp [*, squashSeq]
state_before: K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
gp_n gp_succ_n : Pair K
s_nth_eq : Stream'.Seq.get? s n = some gp_n
s_succ_nth_eq : Stream'.Seq.get? s (n + 1) = some gp_succ_n
⊢ Stream'.Seq.get? (squashSeq s n) n = some { a := gp_n.a, b := gp_n.b + gp_succ_n.a / gp_succ_n.b }
Theorem: Rat.totallyBounded_Icc
File: Mathlib/Topology/Instances/Rat.lean

tactic: simpa only [preimage_cast_Icc] using
  totallyBounded_preimage Rat.uniformEmbedding_coe_real (totallyBounded_Icc (a : ℝ) b)
state_before: a b : ℚ
⊢ TotallyBounded (Icc a b)
Theorem: Nat.factorization_prod
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext p
state_before: α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ (x : α), x ∈ S → g x ≠ 0
⊢ factorization (Finset.prod S g) = ∑ x in S, factorization (g x)

tactic: refine' Finset.induction_on' S ?_ ?_
state_before: case h
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ (x : α), x ∈ S → g x ≠ 0
p : ℕ
⊢ ↑(factorization (Finset.prod S g)) p = ↑(∑ x in S, factorization (g x)) p

tactic: simp
state_before: case h.refine'_1
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ (x : α), x ∈ S → g x ≠ 0
p : ℕ
⊢ ↑(factorization (Finset.prod ∅ g)) p = ↑(∑ x in ∅, factorization (g x)) p

tactic: intro x T hxS hTS hxT IH
state_before: case h.refine'_2
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ (x : α), x ∈ S → g x ≠ 0
p : ℕ
⊢ ∀ {a : α} {s : Finset α},
    a ∈ S →
      s ⊆ S →
        ¬a ∈ s →
          ↑(factorization (Finset.prod s g)) p = ↑(∑ x in s, factorization (g x)) p →
            ↑(factorization (Finset.prod (insert a s) g)) p = ↑(∑ x in insert a s, factorization (g x)) p

tactic: have hT : T.prod g ≠ 0 := prod_ne_zero_iff.mpr fun x hx => hS x (hTS hx)
state_before: case h.refine'_2
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ (x : α), x ∈ S → g x ≠ 0
p : ℕ
x : α
T : Finset α
hxS : x ∈ S
hTS : T ⊆ S
hxT : ¬x ∈ T
IH : ↑(factorization (Finset.prod T g)) p = ↑(∑ x in T, factorization (g x)) p
⊢ ↑(factorization (Finset.prod (insert x T) g)) p = ↑(∑ x in insert x T, factorization (g x)) p

tactic: simp [prod_insert hxT, sum_insert hxT, ← IH, factorization_mul (hS x hxS) hT]
state_before: case h.refine'_2
α : Type u_1
S : Finset α
g : α → ℕ
hS : ∀ (x : α), x ∈ S → g x ≠ 0
p : ℕ
x : α
T : Finset α
hxS : x ∈ S
hTS : T ⊆ S
hxT : ¬x ∈ T
IH : ↑(factorization (Finset.prod T g)) p = ↑(∑ x in T, factorization (g x)) p
hT : Finset.prod T g ≠ 0
⊢ ↑(factorization (Finset.prod (insert x T) g)) p = ↑(∑ x in insert x T, factorization (g x)) p
Theorem: List.Pairwise.imp_mem
File: Mathlib/Data/List/Pairwise.lean

tactic: simp (config := { contextual := true }) only [forall_prop_of_true, iff_self_iff,
forall₂_true_iff]
state_before: α : Type u_1
β : Type ?u.4602
R S T : α → α → Prop
a : α
l✝ l : List α
⊢ ∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ a ∈ l → b ∈ l → R a b)
Theorem: mul_le_of_le_one_left
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
state_before: α : Type u_1
a b c d : α
inst✝³ : MulOneClass α
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : MulPosMono α
hb : 0 ≤ b
h : a ≤ 1
⊢ a * b ≤ b
Theorem: Std.RBNode.Ordered.setBlack
File: Std/Data/RBMap/WF.lean

tactic: unfold setBlack
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
⊢ Ordered cmp (setBlack t) ↔ Ordered cmp t

tactic: split <;> simp [Ordered]
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
⊢ Ordered cmp
      (match t with
      | nil => nil
      | node c l v r => node black l v r) ↔
    Ordered cmp t
Theorem: IntermediateField.bot_eq_top_of_rank_adjoin_eq_one
File: Mathlib/FieldTheory/Adjoin.lean

tactic: ext y
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), Module.rank F { x_1 // x_1 ∈ F⟮x⟯ } = 1
⊢ ⊥ = ⊤

tactic: rw [iff_true_right IntermediateField.mem_top]
state_before: case h
F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), Module.rank F { x_1 // x_1 ∈ F⟮x⟯ } = 1
y : E
⊢ y ∈ ⊥ ↔ y ∈ ⊤

tactic: exact rank_adjoin_simple_eq_one_iff.mp (h y)
state_before: case h
F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
h : ∀ (x : E), Module.rank F { x_1 // x_1 ∈ F⟮x⟯ } = 1
y : E
⊢ y ∈ ⊥
Theorem: CategoryTheory.Adjunction.eq_homEquiv_apply
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: cases h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : g = ↑(homEquiv adj A B) f
⊢ ↑(homEquiv adj A B).symm g = f

tactic: simp
state_before: case refl
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
⊢ ↑(homEquiv adj A B).symm (↑(homEquiv adj A B) f) = f

tactic: cases h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
f : F.obj A ⟶ B
g : A ⟶ G.obj B
h : ↑(homEquiv adj A B).symm g = f
⊢ g = ↑(homEquiv adj A B) f

tactic: simp
state_before: case refl
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
A : C
B : D
g : A ⟶ G.obj B
⊢ g = ↑(homEquiv adj A B) (↑(homEquiv adj A B).symm g)
Theorem: Int.natAbs_mul
File: Std/Data/Int/Lemmas.lean

tactic: cases a <;> cases b <;>
  simp only [← Int.mul_def, Int.mul, natAbs_negOfNat] <;> simp only [natAbs]
state_before: a b : Int
⊢ natAbs (a * b) = natAbs a * natAbs b
Theorem: Polynomial.IsUnitTrinomial.card_support_eq_three
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: obtain ⟨k, m, n, hkm, hmn, u, v, w, rfl⟩ := hp
state_before: p q : ℤ[X]
hp : IsUnitTrinomial p
⊢ card (support p) = 3

tactic: exact card_support_trinomial hkm hmn u.ne_zero v.ne_zero w.ne_zero
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
q : ℤ[X]
k m n : ℕ
hkm : k < m
hmn : m < n
u v w : ℤˣ
⊢ card (support (trinomial k m n ↑u ↑v ↑w)) = 3
Theorem: IsLocalMaxOn.hasFDerivWithinAt_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simpa using h.hasFDerivWithinAt_nonpos hf hy'
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMaxOn f s a
hf : HasFDerivWithinAt f f' s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
⊢ 0 ≤ ↑f' y
Theorem: Int.bit_val
File: Mathlib/Data/Int/Bitwise.lean

tactic: cases b
state_before: b : Bool
n : ℤ
⊢ bit b n = 2 * n + bif b then 1 else 0

tactic: apply (bit0_val n).trans (add_zero _).symm
state_before: case false
n : ℤ
⊢ bit false n = 2 * n + bif false then 1 else 0

case true
n : ℤ
⊢ bit true n = 2 * n + bif true then 1 else 0

tactic: apply bit1_val
state_before: case true
n : ℤ
⊢ bit true n = 2 * n + bif true then 1 else 0
Theorem: CategoryTheory.isIso_of_hom_comp_eq_id
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [(hom_comp_eq_id _).mp h]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
g : X ⟶ Y
inst✝ : IsIso g
f : Y ⟶ X
h : g ≫ f = 𝟙 X
⊢ IsIso f

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
g : X ⟶ Y
inst✝ : IsIso g
f : Y ⟶ X
h : g ≫ f = 𝟙 X
⊢ IsIso (inv g)
Theorem: Rat.comap_cast_atBot
File: Mathlib/Order/Filter/Archimedean.lean

tactic: simpa [neg_le]
state_before: α : Type ?u.9070
R : Type u_1
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
r : R
n : ℕ
hn : -r ≤ ↑n
⊢ ↑(-↑n) ≤ r
Theorem: Subtype.exists_pi_extension
File: Mathlib/Tactic/Lift.lean

tactic: haveI : DecidablePred p := fun i ↦ Classical.propDecidable (p i)
state_before: ι : Sort u_1
α : ι → Sort u_2
ne : ∀ (i : ι), Nonempty (α i)
p : ι → Prop
f : (i : Subtype p) → α i.val
⊢ ∃ g, (fun i => g i.val) = f

tactic: exact ⟨fun i => if hi : p i then f ⟨i, hi⟩ else Classical.choice (ne i),
  funext fun i ↦ dif_pos i.2⟩
state_before: ι : Sort u_1
α : ι → Sort u_2
ne : ∀ (i : ι), Nonempty (α i)
p : ι → Prop
f : (i : Subtype p) → α i.val
this : DecidablePred p
⊢ ∃ g, (fun i => g i.val) = f
Theorem: Fin.prod_univ_five
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [prod_univ_castSucc, prod_univ_four]
state_before: α : Type ?u.22461
β : Type u_1
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ ∏ i : Fin 5, f i = f 0 * f 1 * f 2 * f 3 * f 4

tactic: rfl
state_before: α : Type ?u.22461
β : Type u_1
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ f (↑castSucc 0) * f (↑castSucc 1) * f (↑castSucc 2) * f (↑castSucc 3) * f (last 4) = f 0 * f 1 * f 2 * f 3 * f 4
Theorem: Continuous.path_trans
File: Mathlib/Topology/PathConnected.lean

tactic: intro hf hg
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.347696
γ : Path x y
f : Y → Path x y
g : Y → Path y z
⊢ Continuous f → Continuous g → Continuous fun t => trans (f t) (g t)

tactic: apply continuous_uncurry_iff.mp
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.347696
γ : Path x y
f : Y → Path x y
g : Y → Path y z
hf : Continuous f
hg : Continuous g
⊢ Continuous fun t => trans (f t) (g t)

tactic: exact trans_continuous_family _ (continuous_uncurry_iff.mpr hf) _ (continuous_uncurry_iff.mpr hg)
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.347696
γ : Path x y
f : Y → Path x y
g : Y → Path y z
hf : Continuous f
hg : Continuous g
⊢ Continuous ↿fun t => trans (f t) (g t)
Theorem: EMetric.tendstoLocallyUniformly_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [← tendstoLocallyUniformlyOn_univ, tendstoLocallyUniformlyOn_iff, mem_univ,
  forall_const, exists_prop, nhdsWithin_univ]
state_before: α : Type u
β : Type v
X : Type ?u.31390
inst✝¹ : PseudoEMetricSpace α
ι : Type u_1
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
⊢ TendstoLocallyUniformly F f p ↔
    ∀ (ε : ℝ≥0∞), ε > 0 → ∀ (x : β), ∃ t, t ∈ 𝓝 x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → edist (f y) (F n y) < ε
Theorem: ZMod.mul_inv_of_unit
File: Mathlib/Data/ZMod/Basic.lean

tactic: rcases h with ⟨u, rfl⟩
state_before: n : ℕ
a : ZMod n
h : IsUnit a
⊢ a * a⁻¹ = 1

tactic: rw [inv_coe_unit, u.mul_inv]
state_before: case intro
n : ℕ
u : (ZMod n)ˣ
⊢ ↑u * (↑u)⁻¹ = 1
Theorem: Basis.coe_ofEquivFun
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.ofEquivFun, ← Finsupp.single_eq_pi_single, Finsupp.single_eq_update]
state_before: ι : Type u_1
ι' : Type ?u.687118
R : Type u_2
R₂ : Type ?u.687124
K : Type ?u.687127
M : Type u_3
M' : Type ?u.687133
M'' : Type ?u.687136
V : Type u
V' : Type ?u.687141
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
inst✝¹ : Fintype ι
b : Basis ι R M
inst✝ : DecidableEq ι
e : M ≃ₗ[R] ι → R
i j : ι
⊢ ↑e (↑(ofEquivFun e) i) j = ↑e (↑(LinearEquiv.symm e) (update 0 i 1)) j
Theorem: Nat.WithBot.coe_nonneg
File: Mathlib/Data/Nat/WithBot.lean

tactic: rw [← WithBot.coe_zero]
state_before: n : ℕ
⊢ 0 ≤ ↑n

tactic: exact WithBot.coe_le_coe.mpr (Nat.zero_le n)
state_before: n : ℕ
⊢ ↑0 ≤ ↑n
Theorem: Complex.tanh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh, neg_div]
state_before: x y : ℂ
⊢ tanh (-x) = -tanh x
Theorem: BoxIntegral.Prepartition.iUnion_top
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [Prepartition.iUnion]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
⊢ Prepartition.iUnion ⊤ = ↑I
Theorem: WithSeminorms.hasBasis_ball
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: haveI : TopologicalAddGroup E := hp.topologicalAddGroup
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.189437
𝕝 : Type ?u.189440
𝕝₂ : Type ?u.189443
E : Type u_2
F : Type ?u.189449
G : Type ?u.189452
ι : Type u_3
ι' : Type ?u.189458
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
x : E
⊢ Filter.HasBasis (𝓝 x) (fun sr => 0 < sr.snd) fun sr => ball (Finset.sup sr.fst p) x sr.snd

tactic: rw [← map_add_left_nhds_zero]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.189437
𝕝 : Type ?u.189440
𝕝₂ : Type ?u.189443
E : Type u_2
F : Type ?u.189449
G : Type ?u.189452
ι : Type u_3
ι' : Type ?u.189458
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
x : E
this : TopologicalAddGroup E
⊢ Filter.HasBasis (𝓝 x) (fun sr => 0 < sr.snd) fun sr => ball (Finset.sup sr.fst p) x sr.snd

tactic: ext sr : 1
state_before: case h.e'_5
𝕜 : Type u_1
𝕜₂ : Type ?u.189437
𝕝 : Type ?u.189440
𝕝₂ : Type ?u.189443
E : Type u_2
F : Type ?u.189449
G : Type ?u.189452
ι : Type u_3
ι' : Type ?u.189458
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
x : E
this : TopologicalAddGroup E
⊢ (fun sr => ball (Finset.sup sr.fst p) x sr.snd) = fun i =>
    (fun x x_1 => x + x_1) x '' ball (Finset.sup i.fst p) 0 i.snd

tactic: have : (sr.fst.sup p).ball (x +ᵥ (0 : E)) sr.snd = x +ᵥ (sr.fst.sup p).ball 0 sr.snd :=
  Eq.symm (Seminorm.vadd_ball (sr.fst.sup p))
state_before: case h.e'_5.h
𝕜 : Type u_1
𝕜₂ : Type ?u.189437
𝕝 : Type ?u.189440
𝕝₂ : Type ?u.189443
E : Type u_2
F : Type ?u.189449
G : Type ?u.189452
ι : Type u_3
ι' : Type ?u.189458
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
x : E
this : TopologicalAddGroup E
sr : Finset ι × ℝ
⊢ ball (Finset.sup sr.fst p) x sr.snd = (fun x x_1 => x + x_1) x '' ball (Finset.sup sr.fst p) 0 sr.snd

tactic: rwa [vadd_eq_add, add_zero] at this
state_before: case h.e'_5.h
𝕜 : Type u_1
𝕜₂ : Type ?u.189437
𝕝 : Type ?u.189440
𝕝₂ : Type ?u.189443
E : Type u_2
F : Type ?u.189449
G : Type ?u.189452
ι : Type u_3
ι' : Type ?u.189458
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
x : E
this✝ : TopologicalAddGroup E
sr : Finset ι × ℝ
this : ball (Finset.sup sr.fst p) (x +ᵥ 0) sr.snd = x +ᵥ ball (Finset.sup sr.fst p) 0 sr.snd
⊢ ball (Finset.sup sr.fst p) x sr.snd = (fun x x_1 => x + x_1) x '' ball (Finset.sup sr.fst p) 0 sr.snd
Theorem: Equiv.prodCongr_refl_right
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
⊢ prodCongr e (Equiv.refl α₁) = prodCongrLeft fun x => e

tactic: simp
state_before: case H.mk
α₁ : Type u_3
β₁ : Type u_1
β₂ : Type u_2
e✝ : α₁ → β₁ ≃ β₂
e : β₁ ≃ β₂
a : β₁
b : α₁
⊢ ↑(prodCongr e (Equiv.refl α₁)) (a, b) = ↑(prodCongrLeft fun x => e) (a, b)
Theorem: BoundedLatticeHom.cancel_left
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.205169
ι : Type ?u.205172
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.205184
inst✝⁷ : Lattice α
inst✝⁶ : Lattice β
inst✝⁵ : Lattice γ
inst✝⁴ : Lattice δ
inst✝³ : BoundedOrder α
inst✝² : BoundedOrder β
inst✝¹ : BoundedOrder γ
inst✝ : BoundedOrder δ
g : BoundedLatticeHom β γ
f₁ f₂ : BoundedLatticeHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: List.mem_of_mem_inter_right
File: Mathlib/Data/List/Lattice.lean

tactic: simpa using of_mem_filter h
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
h : a ∈ l₁ ∩ l₂
⊢ a ∈ l₂
Theorem: Filter.HasBasis.comap
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [mem_comap', hl.mem_iff]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.65846
ι : Sort u_2
ι' : Sort ?u.65852
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f : β → α
hl : HasBasis l p s
t : Set β
⊢ t ∈ Filter.comap f l ↔ ∃ i, p i ∧ f ⁻¹' s i ⊆ t

tactic: refine exists_congr (fun i => Iff.rfl.and ?_)
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.65846
ι : Sort u_2
ι' : Sort ?u.65852
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f : β → α
hl : HasBasis l p s
t : Set β
⊢ (∃ i, p i ∧ s i ⊆ {y | ∀ ⦃x : β⦄, f x = y → x ∈ t}) ↔ ∃ i, p i ∧ f ⁻¹' s i ⊆ t

tactic: exact ⟨fun h x hx => h hx rfl, fun h y hy x hx => h <| by rwa [mem_preimage, hx]⟩
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.65846
ι : Sort u_2
ι' : Sort ?u.65852
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f : β → α
hl : HasBasis l p s
t : Set β
i : ι
⊢ s i ⊆ {y | ∀ ⦃x : β⦄, f x = y → x ∈ t} ↔ f ⁻¹' s i ⊆ t

tactic: rwa [mem_preimage, hx]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.65846
ι : Sort u_2
ι' : Sort ?u.65852
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i✝ : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f : β → α
hl : HasBasis l p s
t : Set β
i : ι
h : f ⁻¹' s i ⊆ t
y : α
hy : y ∈ s i
x : β
hx : f x = y
⊢ x ∈ f ⁻¹' s i
Theorem: Finset.exists_ne_one_of_prod_ne_one
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: classical
  rw [← prod_filter_ne_one] at h
  rcases nonempty_of_prod_ne_one h with ⟨x, hx⟩
  exact ⟨x, (mem_filter.1 hx).1, by simpa using (mem_filter.1 hx).2⟩
state_before: ι : Type ?u.430162
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : ∏ x in s, f x ≠ 1
⊢ ∃ a, a ∈ s ∧ f a ≠ 1

tactic: rw [← prod_filter_ne_one] at h
state_before: ι : Type ?u.430162
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : ∏ x in s, f x ≠ 1
⊢ ∃ a, a ∈ s ∧ f a ≠ 1

tactic: rcases nonempty_of_prod_ne_one h with ⟨x, hx⟩
state_before: ι : Type ?u.430162
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h✝ : ∏ x in s, f x ≠ 1
h : ∏ x in filter (fun x => f x ≠ 1) s, f x ≠ 1
⊢ ∃ a, a ∈ s ∧ f a ≠ 1

tactic: exact ⟨x, (mem_filter.1 hx).1, by simpa using (mem_filter.1 hx).2⟩
state_before: case intro
ι : Type ?u.430162
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h✝ : ∏ x in s, f x ≠ 1
h : ∏ x in filter (fun x => f x ≠ 1) s, f x ≠ 1
x : α
hx : x ∈ filter (fun x => f x ≠ 1) s
⊢ ∃ a, a ∈ s ∧ f a ≠ 1

tactic: simpa using (mem_filter.1 hx).2
state_before: ι : Type ?u.430162
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h✝ : ∏ x in s, f x ≠ 1
h : ∏ x in filter (fun x => f x ≠ 1) s, f x ≠ 1
x : α
hx : x ∈ filter (fun x => f x ≠ 1) s
⊢ f x ≠ 1