tasksource/leandojo huggingface dataset:
Theorem: two_nsmul_eq_zero
File: Mathlib/Algebra/Module/Basic.lean

tactic: haveI := Nat.noZeroSMulDivisors R M
state_before: α : Type ?u.276095
R : Type ?u.276098
k : Type ?u.276101
S : Type ?u.276104
M : Type u_1
M₂ : Type ?u.276110
M₃ : Type ?u.276113
ι : Type ?u.276116
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : CharZero R
v : M
⊢ 2 • v = 0 ↔ v = 0

tactic: simp [smul_eq_zero]
state_before: α : Type ?u.276095
R : Type ?u.276098
k : Type ?u.276101
S : Type ?u.276104
M : Type u_1
M₂ : Type ?u.276110
M₃ : Type ?u.276113
ι : Type ?u.276116
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : CharZero R
v : M
this : NoZeroSMulDivisors ℕ M
⊢ 2 • v = 0 ↔ v = 0
Theorem: CategoryTheory.Presieve.image_mem_functorPushforward
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X
f : Y ⟶ X
h : R f
⊢ F.map f = 𝟙 (F.obj Y) ≫ F.map f
Theorem: Int.le_min
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.min_def]
state_before: a b c : Int
x✝ : a ≤ b ∧ a ≤ c
h₁ : a ≤ b
h₂ : a ≤ c
⊢ a ≤ min b c

tactic: split <;> assumption
state_before: a b c : Int
x✝ : a ≤ b ∧ a ≤ c
h₁ : a ≤ b
h₂ : a ≤ c
⊢ a ≤ if b ≤ c then b else c
Theorem: MeasureTheory.L1.integral_smul
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.484290
𝕜 : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
c : 𝕜
f : { x // x ∈ Lp E 1 }
⊢ integral (c • f) = c • integral f

tactic: show (integralCLM' (E := E) 𝕜) (c • f) = c • (integralCLM' (E := E) 𝕜) f
state_before: α : Type u_1
E : Type u_2
F : Type ?u.484290
𝕜 : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
c : 𝕜
f : { x // x ∈ Lp E 1 }
⊢ ↑integralCLM (c • f) = c • ↑integralCLM f

tactic: exact map_smul (integralCLM' (E := E) 𝕜) c f
state_before: α : Type u_1
E : Type u_2
F : Type ?u.484290
𝕜 : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
c : 𝕜
f : { x // x ∈ Lp E 1 }
⊢ ↑(integralCLM' 𝕜) (c • f) = c • ↑(integralCLM' 𝕜) f
Theorem: CategoryTheory.Limits.Fork.equalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: rw [s.app_one_eq_ι_comp_left, this]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Fork f g
W : C
k l : W ⟶ s.pt
h : k ≫ ι s = l ≫ ι s
this : k ≫ ι s ≫ f = l ≫ ι s ≫ f
⊢ k ≫ s.π.app one = l ≫ s.π.app one

tactic: simp only [← Category.assoc]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Fork f g
W : C
k l : W ⟶ s.pt
h : k ≫ ι s = l ≫ ι s
⊢ k ≫ ι s ≫ f = l ≫ ι s ≫ f
Theorem: compositionAsSet_card
File: Mathlib/Combinatorics/Composition.lean

tactic: have : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1) := by simp
state_before: n✝ n : ℕ
⊢ Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)

tactic: rw [← this]
state_before: n✝ n : ℕ
this : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
⊢ Fintype.card (CompositionAsSet n) = 2 ^ (n - 1)

tactic: exact Fintype.card_congr (compositionAsSetEquiv n)
state_before: n✝ n : ℕ
this : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
⊢ Fintype.card (CompositionAsSet n) = Fintype.card (Finset (Fin (n - 1)))

tactic: simp
state_before: n✝ n : ℕ
⊢ Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1)
Theorem: EMetric.mk_uniformity_basis_le
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: refine' ⟨fun s => uniformity_basis_edist.mem_iff.trans _⟩
state_before: α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
⊢ HasBasis (𝓤 α) p fun x => {p | edist p.fst p.snd ≤ f x}

tactic: constructor
state_before: α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
s : Set (α × α)
⊢ (∃ i, 0 < i ∧ {p | edist p.fst p.snd < i} ⊆ s) ↔ ∃ i, p i ∧ {p | edist p.fst p.snd ≤ f i} ⊆ s

tactic: rintro ⟨ε, ε₀, hε⟩
state_before: case mp
α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
s : Set (α × α)
⊢ (∃ i, 0 < i ∧ {p | edist p.fst p.snd < i} ⊆ s) → ∃ i, p i ∧ {p | edist p.fst p.snd ≤ f i} ⊆ s

tactic: rcases exists_between ε₀ with ⟨ε', hε'⟩
state_before: case mp.intro.intro
α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
s : Set (α × α)
ε : ℝ≥0∞
ε₀ : 0 < ε
hε : {p | edist p.fst p.snd < ε} ⊆ s
⊢ ∃ i, p i ∧ {p | edist p.fst p.snd ≤ f i} ⊆ s

tactic: rcases hf ε' hε'.1 with ⟨i, hi, H⟩
state_before: case mp.intro.intro.intro
α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
s : Set (α × α)
ε : ℝ≥0∞
ε₀ : 0 < ε
hε : {p | edist p.fst p.snd < ε} ⊆ s
ε' : ℝ≥0∞
hε' : 0 < ε' ∧ ε' < ε
⊢ ∃ i, p i ∧ {p | edist p.fst p.snd ≤ f i} ⊆ s

tactic: exact ⟨i, hi, fun x hx => hε <| lt_of_le_of_lt (le_trans hx.out H) hε'.2⟩
state_before: case mp.intro.intro.intro.intro.intro
α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
s : Set (α × α)
ε : ℝ≥0∞
ε₀ : 0 < ε
hε : {p | edist p.fst p.snd < ε} ⊆ s
ε' : ℝ≥0∞
hε' : 0 < ε' ∧ ε' < ε
i : β
hi : p i
H : f i ≤ ε'
⊢ ∃ i, p i ∧ {p | edist p.fst p.snd ≤ f i} ⊆ s

tactic: exact fun ⟨i, hi, H⟩ => ⟨f i, hf₀ i hi, fun x hx => H (le_of_lt hx.out)⟩
state_before: case mpr
α : Type u
β✝ : Type v
X : Type ?u.17483
inst✝ : PseudoEMetricSpace α
β : Type u_1
p : β → Prop
f : β → ℝ≥0∞
hf₀ : ∀ (x : β), p x → 0 < f x
hf : ∀ (ε : ℝ≥0∞), 0 < ε → ∃ x, p x ∧ f x ≤ ε
s : Set (α × α)
⊢ (∃ i, p i ∧ {p | edist p.fst p.snd ≤ f i} ⊆ s) → ∃ i, 0 < i ∧ {p | edist p.fst p.snd < i} ⊆ s
Theorem: CategoryTheory.Limits.ι_colimitLimitToLimitColimit_π_apply
File: Mathlib/CategoryTheory/Limits/ColimitLimit.lean

tactic: dsimp [colimitLimitToLimitColimit]
state_before: J K : Type v
inst✝⁴ : SmallCategory J
inst✝³ : SmallCategory K
C : Type u
inst✝² : Category C
F✝ : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ limit.π (curry.obj F ⋙ colim) j (colimitLimitToLimitColimit F (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f)) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)

tactic: simp
state_before: J K : Type v
inst✝⁴ : SmallCategory J
inst✝³ : SmallCategory K
C : Type u
inst✝² : Category C
F✝ : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
F : J × K ⥤ Type v
j : J
k : K
f : (curry.obj (Prod.swap K J ⋙ F) ⋙ lim).obj k
⊢ limit.π (curry.obj F ⋙ colim) j
      (limit.lift (curry.obj F ⋙ colim)
        { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
          π :=
            NatTrans.mk fun j =>
              colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                { pt := colimit ((curry.obj F).obj j),
                  ι :=
                    NatTrans.mk fun k =>
                      limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k } }
        (colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k f)) =
    colimit.ι ((curry.obj F).obj j) k (limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j f)
Theorem: IsRightRegular.of_mul
File: Mathlib/Algebra/Regular/Basic.lean

tactic: refine' fun x y xy => ab (_ : x * (b * a) = y * (b * a))
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
⊢ IsRightRegular b

tactic: rw [← mul_assoc, ← mul_assoc]
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * (b * a) = y * (b * a)
Theorem: FreimanHom.toFreimanHom_injective
File: Mathlib/Algebra/Hom/Freiman.lean

tactic: convert FunLike.ext_iff.1 hfg using 0
state_before: F : Type ?u.92699
α : Type u_1
β : Type u_2
γ : Type ?u.92708
δ : Type ?u.92711
G : Type ?u.92714
inst✝² : FunLike F α fun x => β
inst✝¹ : CommMonoid α
inst✝ : CancelCommMonoid β
A : Set α
m n : ℕ
h : m ≤ n
f g : A →*[n] β
hfg : toFreimanHom h f = toFreimanHom h g
⊢ ∀ (x : α), ↑f x = ↑g x
Theorem: MeasureTheory.tendsto_setToFun_approxOn_of_measurable_of_range_subset
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp
state_before: α : Type ?u.1577848
E : Type ?u.1577851
F : Type ?u.1577854
F' : Type ?u.1577857
G : Type ?u.1577860
𝕜 : Type ?u.1577863
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
fmeas : Measurable f
hf : Integrable f
s : Set E
inst✝ : SeparableSpace ↑s
hs : Set.range f ∪ {0} ⊆ s
n : ℕ
⊢ 0 ∈ Set.range f ∪ {0}

tactic: refine tendsto_setToFun_approxOn_of_measurable hT hf fmeas ?_ _ (integrable_zero _ _ _)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1577857
G : Type ?u.1577860
𝕜 : Type ?u.1577863
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
fmeas : Measurable f
hf : Integrable f
s : Set E
inst✝ : SeparableSpace ↑s
hs : Set.range f ∪ {0} ⊆ s
⊢ Tendsto (fun n => setToFun μ T hT ↑(SimpleFunc.approxOn f fmeas s 0 (_ : 0 ∈ s) n)) atTop (𝓝 (setToFun μ T hT f))

tactic: exact eventually_of_forall fun x => subset_closure (hs (Set.mem_union_left _ (mem_range_self _)))
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1577857
G : Type ?u.1577860
𝕜 : Type ?u.1577863
p : ℝ≥0∞
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : NormedAddCommGroup F'
inst✝⁵ : NormedSpace ℝ F'
inst✝⁴ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝³ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
fmeas : Measurable f
hf : Integrable f
s : Set E
inst✝ : SeparableSpace ↑s
hs : Set.range f ∪ {0} ⊆ s
⊢ ∀ᵐ (x : α) ∂μ, f x ∈ closure s
Theorem: SimpleGraph.Walk.support_dropUntil_subset
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← take_spec p h, mem_support_append_iff]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
x : V
hx : x ∈ support (dropUntil p u h)
⊢ x ∈ support p

tactic: exact Or.inr hx
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
x : V
hx : x ∈ support (dropUntil p u h)
⊢ x ∈ support (takeUntil p u h) ∨ x ∈ support (dropUntil p u h)
Theorem: piecewise_ae_eq_restrict_compl
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [ae_restrict_eq hs.compl]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4342311
δ : Type ?u.4342314
ι : Type ?u.4342317
R : Type ?u.4342320
R' : Type ?u.4342323
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f g : α → β
hs : MeasurableSet s
⊢ piecewise s f g =ᶠ[ae (Measure.restrict μ (sᶜ))] g

tactic: exact (piecewise_eqOn_compl s f g).eventuallyEq.filter_mono inf_le_right
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4342311
δ : Type ?u.4342314
ι : Type ?u.4342317
R : Type ?u.4342320
R' : Type ?u.4342323
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f g : α → β
hs : MeasurableSet s
⊢ piecewise s f g =ᶠ[ae μ ⊓ 𝓟 (sᶜ)] g
Theorem: Nat.factorization_eq_zero_iff_remainder
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: refine' ⟨factorization_eq_zero_of_remainder i, fun h => _⟩
state_before: p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
⊢ ¬p ∣ r ↔ ↑(factorization (p * i + r)) p = 0

tactic: rw [factorization_eq_zero_iff] at h
state_before: p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : ↑(factorization (p * i + r)) p = 0
⊢ ¬p ∣ r

tactic: contrapose! h
state_before: p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : ¬Prime p ∨ ¬p ∣ p * i + r ∨ p * i + r = 0
⊢ ¬p ∣ r

tactic: refine' ⟨pp, _, _⟩
state_before: p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ Prime p ∧ p ∣ p * i + r ∧ p * i + r ≠ 0

tactic: rwa [← Nat.dvd_add_iff_right (dvd_mul_right p i)]
state_before: case refine'_1
p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ p ∣ p * i + r

tactic: contrapose! hr0
state_before: case refine'_2
p r i : ℕ
pp : Prime p
hr0 : r ≠ 0
h : p ∣ r
⊢ p * i + r ≠ 0

tactic: exact (add_eq_zero_iff.mp hr0).2
state_before: case refine'_2
p r i : ℕ
pp : Prime p
h : p ∣ r
hr0 : p * i + r = 0
⊢ r = 0
Theorem: Nat.mul_div_mul_right
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.mul_comm, Nat.mul_comm k, Nat.mul_div_mul_left _ _ H]
state_before: m n k : Nat
H : 0 < m
⊢ n * m / (k * m) = n / k
Theorem: Set.infinite_of_injective_forall_mem
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← range_subset_iff] at hf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : Infinite α
s : Set β
f : α → β
hi : Injective f
hf : ∀ (x : α), f x ∈ s
⊢ Set.Infinite s

tactic: exact (infinite_range_of_injective hi).mono hf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : Infinite α
s : Set β
f : α → β
hi : Injective f
hf : (range fun x => f x) ⊆ s
⊢ Set.Infinite s
Theorem: AdjoinRoot.mk_eq_zero
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [sub_zero]
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f g : R[X]
⊢ f ∣ g - 0 ↔ f ∣ g
Theorem: geom_sum_pos_and_lt_one
File: Mathlib/Algebra/GeomSum.lean

tactic: refine' Nat.le_induction _ _ n (show 2 ≤ n from hn)
state_before: α : Type u
β : Type ?u.228787
n : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
hn : 1 < n
⊢ 0 < ∑ i in range n, x ^ i ∧ ∑ i in range n, x ^ i < 1

tactic: clear hn
state_before: case refine'_2
α : Type u
β : Type ?u.228787
n : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
hn : 1 < n
⊢ ∀ (n : ℕ),
    2 ≤ n →
      0 < ∑ i in range n, x ^ i ∧ ∑ i in range n, x ^ i < 1 →
        0 < ∑ i in range (n + 1), x ^ i ∧ ∑ i in range (n + 1), x ^ i < 1

tactic: intro n _ ihn
state_before: case refine'_2
α : Type u
β : Type ?u.228787
n : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
⊢ ∀ (n : ℕ),
    2 ≤ n →
      0 < ∑ i in range n, x ^ i ∧ ∑ i in range n, x ^ i < 1 →
        0 < ∑ i in range (n + 1), x ^ i ∧ ∑ i in range (n + 1), x ^ i < 1

tactic: rw [geom_sum_succ, add_lt_iff_neg_right, ← neg_lt_iff_pos_add', neg_mul_eq_neg_mul]
state_before: case refine'_2
α : Type u
β : Type ?u.228787
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
n : ℕ
hn✝ : 2 ≤ n
ihn : 0 < ∑ i in range n, x ^ i ∧ ∑ i in range n, x ^ i < 1
⊢ 0 < ∑ i in range (n + 1), x ^ i ∧ ∑ i in range (n + 1), x ^ i < 1

tactic: exact
  ⟨mul_lt_one_of_nonneg_of_lt_one_left (neg_nonneg.2 hx.le) (neg_lt_iff_pos_add'.2 hx') ihn.2.le,
    mul_neg_of_neg_of_pos hx ihn.1⟩
state_before: case refine'_2
α : Type u
β : Type ?u.228787
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
n : ℕ
hn✝ : 2 ≤ n
ihn : 0 < ∑ i in range n, x ^ i ∧ ∑ i in range n, x ^ i < 1
⊢ -x * ∑ i in range n, x ^ i < 1 ∧ x * ∑ i in range n, x ^ i < 0

tactic: rw [geom_sum_two]
state_before: case refine'_1
α : Type u
β : Type ?u.228787
n : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
hn : 1 < n
⊢ 0 < ∑ i in range 2, x ^ i ∧ ∑ i in range 2, x ^ i < 1

tactic: exact ⟨hx', (add_lt_iff_neg_right _).2 hx⟩
state_before: case refine'_1
α : Type u
β : Type ?u.228787
n : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x < 0
hx' : 0 < x + 1
hn : 1 < n
⊢ 0 < x + 1 ∧ x + 1 < 1
Theorem: Real.logb_lt_iff_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_lt_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hx]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b x < y ↔ x < b ^ y
Theorem: Pullback.continuous_totalSpaceMk
File: Mathlib/Topology/FiberBundle/Constructions.lean

tactic: simp only [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, induced_compose,
  induced_inf, Function.comp, totalSpaceMk, TotalSpace.proj, induced_const, top_inf_eq,
  pullbackTopology_def]
state_before: B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝⁵ : TopologicalSpace B'
inst✝⁴ : TopologicalSpace (TotalSpace E)
inst✝³ : TopologicalSpace F
inst✝² : TopologicalSpace B
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
f : B' → B
x : B'
⊢ Continuous (totalSpaceMk x)

tactic: exact le_of_eq (FiberBundle.totalSpaceMk_inducing F E (f x)).induced
state_before: B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝⁵ : TopologicalSpace B'
inst✝⁴ : TopologicalSpace (TotalSpace E)
inst✝³ : TopologicalSpace F
inst✝² : TopologicalSpace B
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
f : B' → B
x : B'
⊢ instForAllTopologicalSpacePullback E f x ≤ induced (fun x_1 => Pullback.lift f { fst := x, snd := x_1 }) inst✝⁴
Theorem: ENNReal.top_rpow_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp [top_rpow_def, asymm h, ne_of_lt h]
state_before: y : ℝ
h : y < 0
⊢ ⊤ ^ y = 0
Theorem: geometric_hahn_banach_point_open
File: Mathlib/Analysis/NormedSpace/HahnBanach/Separation.lean

tactic: simpa
state_before: 𝕜 : Type ?u.61842
E : Type u_1
inst✝⁴ : TopologicalSpace E
inst✝³ : AddCommGroup E
inst✝² : TopologicalAddGroup E
inst✝¹ : Module ℝ E
inst✝ : ContinuousSMul ℝ E
s t : Set E
x y : E
ht₁ : Convex ℝ t
ht₂ : IsOpen t
disj : ¬x ∈ t
f : E →L[ℝ] ℝ
hf : ∀ (a : E), a ∈ t → ↑f a < ↑f x
⊢ ∀ (b : E), b ∈ t → ↑(-f) x < ↑(-f) b
Theorem: IsLowerSet.thickening'
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

tactic: rw [← ball_mul_one]
state_before: α : Type u_1
ι : Type ?u.557
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (thickening ε s)

tactic: exact hs.mul_left
state_before: α : Type u_1
ι : Type ?u.557
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsLowerSet s
ε : ℝ
⊢ IsLowerSet (ball 1 ε * s)
Theorem: ChainComplex.mkHom_f_succ_succ
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [mkHom, mkHomAux]
state_before: ι : Type ?u.203118
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
P Q : ChainComplex V ℕ
zero : HomologicalComplex.X P 0 ⟶ HomologicalComplex.X Q 0
one : HomologicalComplex.X P 1 ⟶ HomologicalComplex.X Q 1
one_zero_comm : one ≫ HomologicalComplex.d Q 1 0 = HomologicalComplex.d P 1 0 ≫ zero
succ :
  (n : ℕ) →
    (p :
        (f : HomologicalComplex.X P n ⟶ HomologicalComplex.X Q n) ×'
          (f' : HomologicalComplex.X P (n + 1) ⟶ HomologicalComplex.X Q (n + 1)) ×'
            f' ≫ HomologicalComplex.d Q (n + 1) n = HomologicalComplex.d P (n + 1) n ≫ f) →
      (f'' : HomologicalComplex.X P (n + 2) ⟶ HomologicalComplex.X Q (n + 2)) ×'
        f'' ≫ HomologicalComplex.d Q (n + 2) (n + 1) = HomologicalComplex.d P (n + 2) (n + 1) ≫ p.snd.fst
n : ℕ
⊢ HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) (n + 2) =
    (succ n
        { fst := HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) n,
          snd :=
            { fst := HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) (n + 1),
              snd :=
                (_ :
                  HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) (n + 1) ≫
                      HomologicalComplex.d Q (n + 1) n =
                    HomologicalComplex.d P (n + 1) n ≫
                      HomologicalComplex.Hom.f (mkHom P Q zero one one_zero_comm succ) n) } }).fst

tactic: induction n <;> congr
state_before: ι : Type ?u.203118
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
P Q : ChainComplex V ℕ
zero : HomologicalComplex.X P 0 ⟶ HomologicalComplex.X Q 0
one : HomologicalComplex.X P 1 ⟶ HomologicalComplex.X Q 1
one_zero_comm : one ≫ HomologicalComplex.d Q 1 0 = HomologicalComplex.d P 1 0 ≫ zero
succ :
  (n : ℕ) →
    (p :
        (f : HomologicalComplex.X P n ⟶ HomologicalComplex.X Q n) ×'
          (f' : HomologicalComplex.X P (n + 1) ⟶ HomologicalComplex.X Q (n + 1)) ×'
            f' ≫ HomologicalComplex.d Q (n + 1) n = HomologicalComplex.d P (n + 1) n ≫ f) →
      (f'' : HomologicalComplex.X P (n + 2) ⟶ HomologicalComplex.X Q (n + 2)) ×'
        f'' ≫ HomologicalComplex.d Q (n + 2) (n + 1) = HomologicalComplex.d P (n + 2) (n + 1) ≫ p.snd.fst
n : ℕ
⊢ (succ (n + 0) (mkHomAux P Q zero one one_zero_comm succ (n + 0))).fst =
    (succ n
        { fst := (mkHomAux P Q zero one one_zero_comm succ n).fst,
          snd :=
            { fst := (mkHomAux P Q zero one one_zero_comm succ (n + 0)).snd.fst,
              snd :=
                (_ :
                  HomologicalComplex.Hom.f
                        (HomologicalComplex.Hom.mk fun n => (mkHomAux P Q zero one one_zero_comm succ n).fst) (n + 1) ≫
                      HomologicalComplex.d Q (n + 1) n =
                    HomologicalComplex.d P (n + 1) n ≫
                      HomologicalComplex.Hom.f
                        (HomologicalComplex.Hom.mk fun n => (mkHomAux P Q zero one one_zero_comm succ n).fst)
                        n) } }).fst
Theorem: LocalHomeomorph.IsImage.iff_symm_preimage_eq'
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [iff_symm_preimage_eq, ← image_source_inter_eq, ← image_source_inter_eq']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.40463
δ : Type ?u.40466
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
s : Set α
t : Set β
x : α
y : β
⊢ IsImage e s t ↔ e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (e.source ∩ s) = e.target ∩ t