tasksource/leandojo huggingface dataset:
Theorem: IsUnit.inv
File: Mathlib/Algebra/Hom/Units.lean

tactic: rcases h with ⟨u, hu⟩
state_before: F : Type ?u.55988
G : Type ?u.55991
α : Type u_1
M : Type ?u.55997
N : Type ?u.56000
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit a
⊢ IsUnit a⁻¹

tactic: rw [←hu, ← Units.val_inv_eq_inv_val]
state_before: case intro
F : Type ?u.55988
G : Type ?u.55991
α : Type u_1
M : Type ?u.55997
N : Type ?u.56000
inst✝ : DivisionMonoid α
a b c : α
u : αˣ
hu : ↑u = a
⊢ IsUnit a⁻¹

tactic: exact Units.isUnit _
state_before: case intro
F : Type ?u.55988
G : Type ?u.55991
α : Type u_1
M : Type ?u.55997
N : Type ?u.56000
inst✝ : DivisionMonoid α
a b c : α
u : αˣ
hu : ↑u = a
⊢ IsUnit ↑u⁻¹
Theorem: irrational_div_int_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_coe_int, irrational_div_rat_iff, Int.cast_ne_zero]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (x / ↑m) ↔ m ≠ 0 ∧ Irrational x
Theorem: Metric.tendstoUniformly_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff]
state_before: α : Type u
β : Type v
X : Type ?u.82769
ι✝ : Type ?u.82772
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
ι : Type u_1
F : ι → β → α
f : β → α
p : Filter ι
⊢ TendstoUniformly F f p ↔ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι) in p, ∀ (x : β), dist (f x) (F n x) < ε

tactic: simp
state_before: α : Type u
β : Type v
X : Type ?u.82769
ι✝ : Type ?u.82772
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
ι : Type u_1
F : ι → β → α
f : β → α
p : Filter ι
⊢ (∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι) in p, ∀ (x : β), x ∈ univ → dist (f x) (F n x) < ε) ↔
    ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι) in p, ∀ (x : β), dist (f x) (F n x) < ε
Theorem: Polynomial.update_eq_add_sub_coeff
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: ext
state_before: R✝ : Type u
S : Type v
a✝ b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
⊢ update p n a = p + ↑C (a - coeff p n) * X ^ n

tactic: rw [coeff_update_apply, coeff_add, coeff_C_mul_X_pow]
state_before: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ coeff (update p n a) n✝ = coeff (p + ↑C (a - coeff p n) * X ^ n) n✝

tactic: split_ifs with h <;> simp [h]
state_before: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (if n✝ = n then a else coeff p n✝) = coeff p n✝ + if n✝ = n then a - coeff p n else 0
Theorem: balancedCoreAux_subset
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: simpa only [one_smul] using mem_balancedCoreAux_iff.1 hx 1 norm_one.ge
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.42457
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t s : Set E
x : E
hx : x ∈ balancedCoreAux 𝕜 s
⊢ x ∈ s
Theorem: List.foldl_const
File: Mathlib/Logic/Function/Iterate.lean

tactic: induction' l with b l H generalizing a
state_before: α : Type u
β : Type v
f : α → α
a : α
l : List β
⊢ foldl (fun b x => f b) a l = (f^[length l]) a

tactic: rfl
state_before: case nil
α : Type u
β : Type v
f : α → α
a✝ a : α
⊢ foldl (fun b x => f b) a [] = (f^[length []]) a

tactic: rw [length_cons, foldl, iterate_succ_apply, H]
state_before: case cons
α : Type u
β : Type v
f : α → α
a✝ : α
b : β
l : List β
H : ∀ (a : α), foldl (fun b x => f b) a l = (f^[length l]) a
a : α
⊢ foldl (fun b x => f b) a (b :: l) = (f^[length (b :: l)]) a
Theorem: Real.cos_two_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: gcongr
state_before: ⊢ 2 * cos 1 ^ 2 - 1 ≤ 2 * (2 / 3) ^ 2 - 1

tactic: exact cos_one_pos.le
state_before: case h.h.ha

⊢ 0 ≤ cos 1

tactic: apply cos_one_le
state_before: case h.h.hab

⊢ cos 1 ≤ 2 / 3

tactic: norm_num
state_before: ⊢ 2 * (2 / 3) ^ 2 - 1 < 0
Theorem: List.get?_range
File: Std/Data/List/Lemmas.lean

tactic: simp [range_eq_range', get?_range' _ _ h]
state_before: m n : Nat
h : m < n
⊢ get? (range n) m = some m
Theorem: DifferentiableWithinAt.of_dslope
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: simpa only [id, sub_smul_dslope f a, sub_add_cancel] using
  ((differentiableWithinAt_id.sub_const a).smul h).add_const (f a)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : DifferentiableWithinAt 𝕜 (dslope f a) s b
⊢ DifferentiableWithinAt 𝕜 f s b
Theorem: CategoryTheory.Limits.PushoutCocone.epi_inl_of_is_pushout_of_epi
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [← cancel_epi g, ← t.condition_assoc, i]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
ht : IsColimit t
inst✝ : Epi g
W : C
h k : t.pt ⟶ W
i : inl t ≫ h = inl t ≫ k
⊢ inr t ≫ h = inr t ≫ k
Theorem: ZFSet.toSet_pair
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [pair]
state_before: x y : ZFSet
⊢ toSet (pair x y) = {{x}, {x, y}}
Theorem: LinearPMap.IsClosable.graph_closure_eq_closure_graph
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: rw [closure_def hf]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ Submodule.topologicalClosure (graph f) = graph (closure f)

tactic: exact hf.choose_spec
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : IsClosable f
⊢ Submodule.topologicalClosure (graph f) = graph (Exists.choose hf)
Theorem: Submodule.finrank_add_le_finrank_add_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← finrank_sup_add_finrank_inf_eq]
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } ≤ finrank K { x // x ∈ s } + finrank K { x // x ∈ t }

tactic: exact self_le_add_right _ _
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K { x // x ∈ s }
inst✝ : FiniteDimensional K { x // x ∈ t }
⊢ finrank K { x // x ∈ s ⊔ t } ≤ finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t }
Theorem: CategoryTheory.OplaxNatTrans.whiskerLeft_naturality_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality_naturality]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ (↑G.toPrelaxFunctor).obj a
g h : a ⟶ b
β : g ⟶ h
⊢ f ◁ PrelaxFunctor.map₂ G.toPrelaxFunctor β ▷ app θ b ≫ f ◁ naturality θ h =
    f ◁ naturality θ g ≫ f ◁ app θ a ◁ PrelaxFunctor.map₂ H.toPrelaxFunctor β
Theorem: Composition.length_le
File: Mathlib/Combinatorics/Composition.lean

tactic: conv_rhs => rw [← c.blocks_sum]
state_before: n : ℕ
c : Composition n
⊢ length c ≤ n

tactic: exact length_le_sum_of_one_le _ fun i hi => c.one_le_blocks hi
state_before: n : ℕ
c : Composition n
⊢ length c ≤ sum c.blocks
Theorem: Real.continuousAt_const_rpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: have : rpow a = fun x : ℝ => ((a : ℂ) ^ (x : ℂ)).re := by
  ext1 x
  rw [rpow_eq_pow, rpow_def]
state_before: a b : ℝ
h : b ≠ 0
⊢ ContinuousAt (rpow a) b

tactic: rw [this]
state_before: a b : ℝ
h : b ≠ 0
this : rpow a = fun x => (↑a ^ ↑x).re
⊢ ContinuousAt (rpow a) b

tactic: refine' Complex.continuous_re.continuousAt.comp _
state_before: a b : ℝ
h : b ≠ 0
this : rpow a = fun x => (↑a ^ ↑x).re
⊢ ContinuousAt (fun x => (↑a ^ ↑x).re) b

tactic: refine' (continuousAt_const_cpow' _).comp Complex.continuous_ofReal.continuousAt
state_before: a b : ℝ
h : b ≠ 0
this : rpow a = fun x => (↑a ^ ↑x).re
⊢ ContinuousAt (fun x => ↑a ^ ↑x) b

tactic: norm_cast
state_before: a b : ℝ
h : b ≠ 0
this : rpow a = fun x => (↑a ^ ↑x).re
⊢ ↑b ≠ 0

tactic: ext1 x
state_before: a b : ℝ
h : b ≠ 0
⊢ rpow a = fun x => (↑a ^ ↑x).re

tactic: rw [rpow_eq_pow, rpow_def]
state_before: case h
a b : ℝ
h : b ≠ 0
x : ℝ
⊢ rpow a x = (↑a ^ ↑x).re
Theorem: Multiset.countp_sub
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [countp_eq_card_filter, h, filter_le_filter]
state_before: α : Type u_1
β : Type ?u.308016
γ : Type ?u.308019
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidableEq α
s t : Multiset α
h : t ≤ s
⊢ countp p (s - t) = countp p s - countp p t
Theorem: Equiv.Perm.IsSwap.of_subtype_isSwap
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp only [Ne.def, Subtype.ext_iff] at hxy
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : IsSwap f
x : α
hx : p x
y : α
hy : p y
hxy :
  { val := x, property := hx } ≠ { val := y, property := hy } ∧
    f = swap { val := x, property := hx } { val := y, property := hy }
⊢ x ≠ y

tactic: exact hxy.1
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : IsSwap f
x : α
hx : p x
y : α
hy : p y
hxy : ¬x = y ∧ f = swap { val := x, property := hx } { val := y, property := hy }
⊢ x ≠ y

tactic: rw [hxy.2, ofSubtype_swap_eq]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
f : Perm (Subtype p)
h : IsSwap f
x : α
hx : p x
y : α
hy : p y
hxy :
  { val := x, property := hx } ≠ { val := y, property := hy } ∧
    f = swap { val := x, property := hx } { val := y, property := hy }
⊢ ↑ofSubtype f = swap x y
Theorem: Int.dist_cast_rat
File: Mathlib/Topology/Instances/Rat.lean

tactic: rw [← Int.dist_cast_real, ← Rat.dist_cast]
state_before: x y : ℤ
⊢ dist ↑x ↑y = dist x y

tactic: congr
state_before: x y : ℤ
⊢ dist ↑↑x ↑↑y = dist ↑x ↑y
Theorem: MeasureTheory.measure_biUnion_lt_top
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: convert(measure_biUnion_finset_le hs.toFinset f).trans_lt _ using 3
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.25458
δ : Type ?u.25461
ι : Type ?u.25464
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Finite s
hfin : ∀ (i : β), i ∈ s → ↑↑μ (f i) ≠ ⊤
⊢ ↑↑μ (⋃ (i : β) (_ : i ∈ s), f i) < ⊤

tactic: apply ENNReal.sum_lt_top
state_before: case convert_3
α : Type u_2
β : Type u_1
γ : Type ?u.25458
δ : Type ?u.25461
ι : Type ?u.25464
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Finite s
hfin : ∀ (i : β), i ∈ s → ↑↑μ (f i) ≠ ⊤
⊢ ∑ p in Finite.toFinset hs, ↑↑μ (f p) < ⊤

tactic: simpa only [Finite.mem_toFinset]
state_before: case convert_3.h
α : Type u_2
β : Type u_1
γ : Type ?u.25458
δ : Type ?u.25461
ι : Type ?u.25464
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Finite s
hfin : ∀ (i : β), i ∈ s → ↑↑μ (f i) ≠ ⊤
⊢ ∀ (a : β), a ∈ Finite.toFinset hs → ↑↑μ (f a) ≠ ⊤

tactic: ext
state_before: case h.e'_3.h.e'_3.h.e'_3
α : Type u_2
β : Type u_1
γ : Type ?u.25458
δ : Type ?u.25461
ι : Type ?u.25464
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Finite s
hfin : ∀ (i : β), i ∈ s → ↑↑μ (f i) ≠ ⊤
⊢ (fun i => ⋃ (_ : i ∈ s), f i) = fun b => ⋃ (_ : b ∈ Finite.toFinset hs), f b

tactic: rw [Finite.mem_toFinset]
state_before: case h.e'_3.h.e'_3.h.e'_3.h.h
α : Type u_2
β : Type u_1
γ : Type ?u.25458
δ : Type ?u.25461
ι : Type ?u.25464
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
f : β → Set α
hs : Set.Finite s
hfin : ∀ (i : β), i ∈ s → ↑↑μ (f i) ≠ ⊤
x✝¹ : β
x✝ : α
⊢ (x✝ ∈ ⋃ (_ : x✝¹ ∈ s), f x✝¹) ↔ x✝ ∈ ⋃ (_ : x✝¹ ∈ Finite.toFinset hs), f x✝¹
Theorem: EReal.sign_neg
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← coe_neg, sign_coe, sign_coe, Left.sign_neg]
state_before: x : ℝ
⊢ ↑sign (-↑x) = -↑sign ↑x
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (↑Fin.castSucc i) = 𝟙 (X.obj [n].op)

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_self, op_id, X.map_id]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.σ i).op ≫ X.map (SimplexCategory.δ (↑Fin.castSucc i)).op = 𝟙 (X.obj [n].op)
Theorem: Polynomial.Chebyshev.U_two
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: simp only [U]
state_before: R : Type u_1
S : Type ?u.9628
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ U R 2 = 4 * X ^ 2 - 1

tactic: ring
state_before: R : Type u_1
S : Type ?u.9628
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ 2 * X * (2 * X) - 1 = 4 * X ^ 2 - 1
Theorem: Finset.eq_univ_of_card
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [hs, Finset.card_univ]
state_before: α : Type u_1
β : Type ?u.7801
γ : Type ?u.7804
inst✝ : Fintype α
s : Finset α
hs : card s = Fintype.card α
⊢ card univ ≤ card s
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_empty
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [IsCaratheodory, m.empty, diff_empty]
state_before: α : Type u
m : OuterMeasure α
s s₁ s₂ : Set α
⊢ IsCaratheodory m ∅
Theorem: geom_sum_alternating_of_le_neg_one
File: Mathlib/Algebra/GeomSum.lean

tactic: have hx0 : x ≤ 0 := (le_add_of_nonneg_right zero_le_one).trans hx
state_before: α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
n : ℕ
⊢ if Even n then ∑ i in range n, x ^ i ≤ 0 else 1 ≤ ∑ i in range n, x ^ i

tactic: induction' n with n ih
state_before: α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
n : ℕ
hx0 : x ≤ 0
⊢ if Even n then ∑ i in range n, x ^ i ≤ 0 else 1 ≤ ∑ i in range n, x ^ i

tactic: simp only [Nat.even_add_one, geom_sum_succ]
state_before: case succ
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
ih : if Even n then ∑ i in range n, x ^ i ≤ 0 else 1 ≤ ∑ i in range n, x ^ i
⊢ if Even (Nat.succ n) then ∑ i in range (Nat.succ n), x ^ i ≤ 0 else 1 ≤ ∑ i in range (Nat.succ n), x ^ i

tactic: split_ifs at ih with h
state_before: case succ
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
ih : if Even n then ∑ i in range n, x ^ i ≤ 0 else 1 ≤ ∑ i in range n, x ^ i
⊢ if ¬Even n then x * ∑ i in range n, x ^ i + 1 ≤ 0 else 1 ≤ x * ∑ i in range n, x ^ i + 1

tactic: simp only [Nat.zero_eq, range_zero, sum_empty, le_refl, ite_true]
state_before: case zero
α : Type u
β : Type ?u.231983
n : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
⊢ if Even Nat.zero then ∑ i in range Nat.zero, x ^ i ≤ 0 else 1 ≤ ∑ i in range Nat.zero, x ^ i

tactic: rw [if_neg (not_not_intro h), le_add_iff_nonneg_left]
state_before: case succ.inl
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
h : Even n
ih : ∑ i in range n, x ^ i ≤ 0
⊢ if ¬Even n then x * ∑ i in range n, x ^ i + 1 ≤ 0 else 1 ≤ x * ∑ i in range n, x ^ i + 1

tactic: exact mul_nonneg_of_nonpos_of_nonpos hx0 ih
state_before: case succ.inl
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
h : Even n
ih : ∑ i in range n, x ^ i ≤ 0
⊢ 0 ≤ x * ∑ i in range n, x ^ i

tactic: rw [if_pos h]
state_before: case succ.inr
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
h : ¬Even n
ih : 1 ≤ ∑ i in range n, x ^ i
⊢ if ¬Even n then x * ∑ i in range n, x ^ i + 1 ≤ 0 else 1 ≤ x * ∑ i in range n, x ^ i + 1

tactic: refine' (add_le_add_right _ _).trans hx
state_before: case succ.inr
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
h : ¬Even n
ih : 1 ≤ ∑ i in range n, x ^ i
⊢ x * ∑ i in range n, x ^ i + 1 ≤ 0

tactic: simpa only [mul_one] using mul_le_mul_of_nonpos_left ih hx0
state_before: case succ.inr
α : Type u
β : Type ?u.231983
n✝ : ℕ
x : α
inst✝ : StrictOrderedRing α
hx : x + 1 ≤ 0
hx0 : x ≤ 0
n : ℕ
h : ¬Even n
ih : 1 ≤ ∑ i in range n, x ^ i
⊢ x * ∑ i in range n, x ^ i ≤ x
Theorem: tendsto_subtype_rng
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_subtype_eq_comap, tendsto_comap_iff]
state_before: α : Type u
β✝ : Type v
γ : Type ?u.159970
δ : Type ?u.159973
ε : Type ?u.159976
ζ : Type ?u.159979
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β✝
inst✝ : TopologicalSpace γ
p✝ : α → Prop
β : Type u_1
p : α → Prop
b : Filter β
f : β → Subtype p
a : α
ha : p a
⊢ Tendsto f b (𝓝 { val := a, property := ha }) ↔ Tendsto (fun x => ↑(f x)) b (𝓝 ↑{ val := a, property := ha })

tactic: rfl
state_before: α : Type u
β✝ : Type v
γ : Type ?u.159970
δ : Type ?u.159973
ε : Type ?u.159976
ζ : Type ?u.159979
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β✝
inst✝ : TopologicalSpace γ
p✝ : α → Prop
β : Type u_1
p : α → Prop
b : Filter β
f : β → Subtype p
a : α
ha : p a
⊢ Tendsto (Subtype.val ∘ f) b (𝓝 a) ↔ Tendsto (fun x => ↑(f x)) b (𝓝 ↑{ val := a, property := ha })
Theorem: mem_interior
File: Mathlib/Topology/Basic.lean

tactic: simp only [interior, mem_sUnion, mem_setOf_eq, and_assoc, and_left_comm]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
x : α
⊢ x ∈ interior s ↔ ∃ t, t ⊆ s ∧ IsOpen t ∧ x ∈ t
Theorem: List.map_zipWith
File: Mathlib/Data/List/Zip.lean

tactic: induction' l with hd tl hl generalizing l'
state_before: α : Type u
β : Type u_3
γ : Type u_2
δ✝ : Type ?u.62572
ε : Type ?u.62575
δ : Type u_1
f : α → β
g : γ → δ → α
l : List γ
l' : List δ
⊢ map f (zipWith g l l') = zipWith (fun x y => f (g x y)) l l'

tactic: simp
state_before: case nil
α : Type u
β : Type u_3
γ : Type u_2
δ✝ : Type ?u.62572
ε : Type ?u.62575
δ : Type u_1
f : α → β
g : γ → δ → α
l'✝ l' : List δ
⊢ map f (zipWith g [] l') = zipWith (fun x y => f (g x y)) [] l'

tactic: cases l'
state_before: case cons
α : Type u
β : Type u_3
γ : Type u_2
δ✝ : Type ?u.62572
ε : Type ?u.62575
δ : Type u_1
f : α → β
g : γ → δ → α
l'✝ : List δ
hd : γ
tl : List γ
hl : ∀ (l' : List δ), map f (zipWith g tl l') = zipWith (fun x y => f (g x y)) tl l'
l' : List δ
⊢ map f (zipWith g (hd :: tl) l') = zipWith (fun x y => f (g x y)) (hd :: tl) l'

tactic: simp
state_before: case cons.nil
α : Type u
β : Type u_3
γ : Type u_2
δ✝ : Type ?u.62572
ε : Type ?u.62575
δ : Type u_1
f : α → β
g : γ → δ → α
l' : List δ
hd : γ
tl : List γ
hl : ∀ (l' : List δ), map f (zipWith g tl l') = zipWith (fun x y => f (g x y)) tl l'
⊢ map f (zipWith g (hd :: tl) []) = zipWith (fun x y => f (g x y)) (hd :: tl) []

tactic: simp [hl]
state_before: case cons.cons
α : Type u
β : Type u_3
γ : Type u_2
δ✝ : Type ?u.62572
ε : Type ?u.62575
δ : Type u_1
f : α → β
g : γ → δ → α
l' : List δ
hd : γ
tl : List γ
hl : ∀ (l' : List δ), map f (zipWith g tl l') = zipWith (fun x y => f (g x y)) tl l'
head✝ : δ
tail✝ : List δ
⊢ map f (zipWith g (hd :: tl) (head✝ :: tail✝)) = zipWith (fun x y => f (g x y)) (hd :: tl) (head✝ :: tail✝)
Theorem: CategoryTheory.Limits.colimit.map_desc
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: apply Limits.colimit.hom_ext
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
⊢ colimMap α ≫ desc G c = desc F ((Cocones.precompose α).obj c)

tactic: intro j
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
⊢ ∀ (j : J), ι F j ≫ colimMap α ≫ desc G c = ι F j ≫ desc F ((Cocones.precompose α).obj c)

tactic: simp [← assoc, colimit.ι_map, assoc, colimit.ι_desc, colimit.ι_desc]
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F : J ⥤ C
inst✝ : HasColimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
c : Cocone G
j : J
⊢ ι F j ≫ colimMap α ≫ desc G c = ι F j ≫ desc F ((Cocones.precompose α).obj c)
Theorem: Nat.not_exists_sq'
File: Mathlib/Data/Nat/Sqrt.lean

tactic: simpa only [pow_two] using
  not_exists_sq (by simpa only [pow_two] using hl) (by simpa only [pow_two] using hr)
state_before: n m : ℕ
hl : m ^ 2 < n
hr : n < (m + 1) ^ 2
⊢ ¬∃ t, t ^ 2 = n

tactic: simpa only [pow_two] using hl
state_before: n m : ℕ
hl : m ^ 2 < n
hr : n < (m + 1) ^ 2
⊢ ?m.11299 * ?m.11299 < n

tactic: simpa only [pow_two] using hr
state_before: n m : ℕ
hl : m ^ 2 < n
hr : n < (m + 1) ^ 2
⊢ n < (m + 1) * (m + 1)
Theorem: Matrix.cons_dotProduct_cons
File: Mathlib/Data/Matrix/Notation.lean

tactic: simp
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
x : α
v : Fin n → α
y : α
w : Fin n → α
⊢ vecCons x v ⬝ᵥ vecCons y w = x * y + v ⬝ᵥ w
Theorem: MeasurableSpace.DynkinSystem.has_union
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: rw [union_eq_iUnion]
state_before: α : Type u_1
d : DynkinSystem α
s₁ s₂ : Set α
h₁ : Has d s₁
h₂ : Has d s₂
h : Disjoint s₁ s₂
⊢ Has d (s₁ ∪ s₂)

tactic: exact d.has_iUnion (pairwise_disjoint_on_bool.2 h) (Bool.forall_bool.2 ⟨h₂, h₁⟩)
state_before: α : Type u_1
d : DynkinSystem α
s₁ s₂ : Set α
h₁ : Has d s₁
h₂ : Has d s₂
h : Disjoint s₁ s₂
⊢ Has d (⋃ (b : Bool), bif b then s₁ else s₂)