tasksource/leandojo huggingface dataset:
Theorem: Bool.and_not_self
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (x : Bool), (x && !x) = false
Theorem: nonPrincipals_zorn
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: refine' ⟨sSup c, _, fun J hJ => le_sSup hJ⟩
state_before: R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
⊢ ∃ I, I ∈ nonPrincipals R ∧ ∀ (J : Ideal R), J ∈ c → J ≤ I

tactic: rintro ⟨x, hx⟩
state_before: R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
⊢ sSup c ∈ nonPrincipals R

tactic: have hxmem : x ∈ sSup c := hx.symm ▸ Submodule.mem_span_singleton_self x
state_before: case mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
⊢ False

tactic: obtain ⟨J, hJc, hxJ⟩ := (Submodule.mem_sSup_of_directed ⟨K, hKmem⟩ hchain.directedOn).1 hxmem
state_before: case mk.intro
R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
hxmem : x ∈ sSup c
⊢ False

tactic: have hsSupJ : sSup c = J := le_antisymm (by simp [hx, Ideal.span_le, hxJ]) (le_sSup hJc)
state_before: case mk.intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
hxmem : x ∈ sSup c
J : Submodule R R
hJc : J ∈ c
hxJ : x ∈ J
⊢ False

tactic: specialize hs hJc
state_before: case mk.intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
hxmem : x ∈ sSup c
J : Submodule R R
hJc : J ∈ c
hxJ : x ∈ J
hsSupJ : sSup c = J
⊢ False

tactic: rw [← hsSupJ, hx, nonPrincipals_def] at hs
state_before: case mk.intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
hxmem : x ∈ sSup c
J : Submodule R R
hJc : J ∈ c
hxJ : x ∈ J
hsSupJ : sSup c = J
hs : J ∈ nonPrincipals R
⊢ False

tactic: exact hs ⟨⟨x, rfl⟩⟩
state_before: case mk.intro.intro.intro
R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
hxmem : x ∈ sSup c
J : Submodule R R
hJc : J ∈ c
hxJ : x ∈ J
hsSupJ : sSup c = J
hs : ¬IsPrincipal (Submodule.span R {x})
⊢ False

tactic: simp [hx, Ideal.span_le, hxJ]
state_before: R : Type u
M : Type v
inst✝ : CommRing R
c : Set (Ideal R)
hs : c ⊆ nonPrincipals R
hchain : IsChain (fun x x_1 => x ≤ x_1) c
K : Ideal R
hKmem : K ∈ c
x : R
hx : sSup c = Submodule.span R {x}
hxmem : x ∈ sSup c
J : Submodule R R
hJc : J ∈ c
hxJ : x ∈ J
⊢ sSup c ≤ J
Theorem: integral_one_div_of_pos
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [one_div, integral_inv_of_pos ha hb]
state_before: a b : ℝ
n : ℕ
ha : 0 < a
hb : 0 < b
⊢ (∫ (x : ℝ) in a..b, 1 / x) = Real.log (b / a)
Theorem: ProjectiveSpectrum.zeroLocus_singleton_pow
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simpa using x.isPrime.pow_mem_iff_mem n hn
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
n : ℕ
hn : 0 < n
x : ProjectiveSpectrum 𝒜
⊢ x ∈ zeroLocus 𝒜 {f ^ n} ↔ x ∈ zeroLocus 𝒜 {f}
Theorem: Finset.product_sdiff_offDiag
File: Mathlib/Data/Finset/Prod.lean

tactic: rw [← diag_union_offDiag, union_sdiff_self, sdiff_eq_self_of_disjoint (disjoint_diag_offDiag _)]
state_before: α : Type u_1
β : Type ?u.120722
γ : Type ?u.120725
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ s ×ˢ s \ offDiag s = diag s
Theorem: List.zipWith_rotate_distrib
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_drop_append_take_mod, rotate_eq_drop_append_take_mod,
  rotate_eq_drop_append_take_mod, h, zipWith_append, ← zipWith_distrib_drop, ←
  zipWith_distrib_take, List.length_zipWith, h, min_self]
state_before: α✝ : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → γ
l : List α
l' : List β
n : ℕ
h : length l = length l'
⊢ rotate (zipWith f l l') n = zipWith f (rotate l n) (rotate l' n)

tactic: rw [length_drop, length_drop, h]
state_before: case h
α✝ : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β → γ
l : List α
l' : List β
n : ℕ
h : length l = length l'
⊢ length (drop (n % length l') l) = length (drop (n % length l') l')
Theorem: List.enumFrom_map
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH
state_before: ι : Type ?u.450424
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
l : List α
f : α → β
⊢ enumFrom n (map f l) = map (Prod.map id f) (enumFrom n l)

tactic: rfl
state_before: case nil
ι : Type ?u.450424
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
f : α → β
⊢ enumFrom n (map f []) = map (Prod.map id f) (enumFrom n [])

tactic: rw [map_cons, enumFrom_cons', enumFrom_cons', map_cons, map_map, IH, map_map]
state_before: case cons
ι : Type ?u.450424
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
f : α → β
hd : α
tl : List α
IH : enumFrom n (map f tl) = map (Prod.map id f) (enumFrom n tl)
⊢ enumFrom n (map f (hd :: tl)) = map (Prod.map id f) (enumFrom n (hd :: tl))

tactic: rfl
state_before: case cons
ι : Type ?u.450424
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
f : α → β
hd : α
tl : List α
IH : enumFrom n (map f tl) = map (Prod.map id f) (enumFrom n tl)
⊢ (n, f hd) :: map (Prod.map succ id ∘ Prod.map id f) (enumFrom n tl) =
    Prod.map id f (n, hd) :: map (Prod.map id f ∘ Prod.map succ id) (enumFrom n tl)
Theorem: Basis.reindexRange_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rcases x with ⟨bi, ⟨i, rfl⟩⟩
state_before: ι : Type u_2
ι' : Type ?u.390057
R : Type u_3
R₂ : Type ?u.390063
K : Type ?u.390066
M : Type u_1
M' : Type ?u.390072
M'' : Type ?u.390075
V : Type u
V' : Type ?u.390080
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x✝ : M
b' : Basis ι' R M'
e : ι ≃ ι'
x : ↑(range ↑b)
⊢ ↑(reindexRange b) x = ↑x

tactic: exact b.reindexRange_self i
state_before: case mk.intro
ι : Type u_2
ι' : Type ?u.390057
R : Type u_3
R₂ : Type ?u.390063
K : Type ?u.390066
M : Type u_1
M' : Type ?u.390072
M'' : Type ?u.390075
V : Type u
V' : Type ?u.390080
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
i : ι
⊢ ↑(reindexRange b) { val := ↑b i, property := (_ : ∃ y, ↑b y = ↑b i) } =
    ↑{ val := ↑b i, property := (_ : ∃ y, ↑b y = ↑b i) }
Theorem: Finset.filter_nonempty_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [nonempty_iff_ne_empty, Ne.def, filter_eq_empty_iff, not_not, not_forall]
state_before: α : Type u_1
β : Type ?u.324507
γ : Type ?u.324510
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s : Finset α
⊢ Finset.Nonempty (filter p s) ↔ ∃ a, a ∈ s ∧ p a
Theorem: StrictConvexSpace.ofStrictConvexClosedUnitBall
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: simpa only [smul_closedUnitBall_of_nonneg hr.le] using h.smul r
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : LinearMap.CompatibleSMul E E 𝕜 ℝ
h : StrictConvex 𝕜 (closedBall 0 1)
r : ℝ
hr : 0 < r
⊢ StrictConvex 𝕜 (closedBall 0 r)
Theorem: Filter.map₂_left_comm
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_swap m', map₂_swap m]
state_before: α : Type u_2
α' : Type ?u.38698
β : Type u_4
β' : Type ?u.38704
γ : Type u_5
γ' : Type ?u.38710
δ : Type u_3
δ' : Type u_6
ε : Type u_1
ε' : Type ?u.38722
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ m f (map₂ n g h) = map₂ n' g (map₂ m' f h)

tactic: exact map₂_assoc fun _ _ _ => h_left_comm _ _ _
state_before: α : Type u_2
α' : Type ?u.38698
β : Type u_4
β' : Type ?u.38704
γ : Type u_5
γ' : Type ?u.38710
δ : Type u_3
δ' : Type u_6
ε : Type u_1
ε' : Type ?u.38722
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ (fun a b => m b a) (map₂ n g h) f = map₂ n' g (map₂ (fun a b => m' b a) h f)
Theorem: Finsupp.sum_univ_single'
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp_rw [single, coe_mk]
state_before: α : Type u_2
ι : Type ?u.487120
γ : Type ?u.487123
A : Type ?u.487126
B : Type ?u.487129
C : Type ?u.487132
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.490262
M : Type u_1
M' : Type ?u.490268
N : Type ?u.490271
P : Type ?u.490274
G : Type ?u.490277
H : Type ?u.490280
R : Type ?u.490283
S : Type ?u.490286
inst✝¹ : AddCommMonoid M
inst✝ : Fintype α
i : α
m : M
⊢ ∑ j : α, ↑(single j m) i = m

tactic: classical rw [Finset.sum_pi_single]
state_before: α : Type u_2
ι : Type ?u.487120
γ : Type ?u.487123
A : Type ?u.487126
B : Type ?u.487129
C : Type ?u.487132
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.490262
M : Type u_1
M' : Type ?u.490268
N : Type ?u.490271
P : Type ?u.490274
G : Type ?u.490277
H : Type ?u.490280
R : Type ?u.490283
S : Type ?u.490286
inst✝¹ : AddCommMonoid M
inst✝ : Fintype α
i : α
m : M
⊢ ∑ x : α, Pi.single x m i = m

tactic: simp
state_before: α : Type u_2
ι : Type ?u.487120
γ : Type ?u.487123
A : Type ?u.487126
B : Type ?u.487129
C : Type ?u.487132
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.490262
M : Type u_1
M' : Type ?u.490268
N : Type ?u.490271
P : Type ?u.490274
G : Type ?u.490277
H : Type ?u.490280
R : Type ?u.490283
S : Type ?u.490286
inst✝¹ : AddCommMonoid M
inst✝ : Fintype α
i : α
m : M
⊢ (if i ∈ univ then m else 0) = m

tactic: rw [Finset.sum_pi_single]
state_before: α : Type u_2
ι : Type ?u.487120
γ : Type ?u.487123
A : Type ?u.487126
B : Type ?u.487129
C : Type ?u.487132
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.490262
M : Type u_1
M' : Type ?u.490268
N : Type ?u.490271
P : Type ?u.490274
G : Type ?u.490277
H : Type ?u.490280
R : Type ?u.490283
S : Type ?u.490286
inst✝¹ : AddCommMonoid M
inst✝ : Fintype α
i : α
m : M
⊢ ∑ x : α, Pi.single x m i = m
Theorem: Int.gcd_neg_left
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.gcd, Int.gcd, natAbs_neg]
state_before: x y : ℤ
⊢ gcd (-x) y = gcd x y
Theorem: Monotone.le_map_sSup
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [sSup_eq_iSup]
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.78898
γ : Type ?u.78901
ι : Sort ?u.78904
ι' : Sort ?u.78907
κ : ι → Sort ?u.78912
κ' : ι' → Sort ?u.78917
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Monotone f
⊢ (⨆ (a : α) (_ : a ∈ s), f a) ≤ f (sSup s)

tactic: exact hf.le_map_iSup₂ _
state_before: α : Type u_2
β : Type u_1
β₂ : Type ?u.78898
γ : Type ?u.78901
ι : Sort ?u.78904
ι' : Sort ?u.78907
κ : ι → Sort ?u.78912
κ' : ι' → Sort ?u.78917
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Monotone f
⊢ (⨆ (a : α) (_ : a ∈ s), f a) ≤ f (⨆ (a : α) (_ : a ∈ s), a)
Theorem: IsMonoidHom.comp
File: Mathlib/Deprecated/Group.lean

tactic: rw [hf.map_one, hg.map_one]
state_before: α : Type u
β : Type v
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
f : α → β
hf : IsMonoidHom f
γ : Type u_1
inst✝ : MulOneClass γ
g : β → γ
hg : IsMonoidHom g
src✝ : IsMulHom (g ∘ f) := IsMulHom.comp hf.toIsMulHom hg.toIsMulHom
⊢ g (f 1) = 1
Theorem: Lagrange.interpolate_eq_of_values_eq_on
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [hrr' _ hi]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i✝ j : ι
v r r' : ι → F
hrr' : ∀ (i : ι), i ∈ s → r i = r' i
i : ι
hi : i ∈ s
⊢ ↑C (r i) * Lagrange.basis s v i = ↑C (r' i) * Lagrange.basis s v i
Theorem: HomologicalComplex.xPrevIsoSelf_comp_dTo
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: simp [h]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
j : ι
h : ¬ComplexShape.Rel c (ComplexShape.prev c j) j
⊢ (xPrevIsoSelf C h).inv ≫ dTo C j = 0
Theorem: StieltjesFunction.measure_Ici
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine' tendsto_nhds_unique (tendsto_measure_Ico_atTop _ _) _
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
⊢ ↑↑(StieltjesFunction.measure f) (Ici x) = ofReal (l - leftLim (↑f) x)

tactic: simp_rw [measure_Ico]
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => ↑↑(StieltjesFunction.measure f) (Ico x x_1)) atTop (𝓝 (ofReal (l - leftLim (↑f) x)))

tactic: refine' ENNReal.tendsto_ofReal (Tendsto.sub_const _ _)
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => ofReal (leftLim (↑f) x_1 - leftLim (↑f) x)) atTop (𝓝 (ofReal (l - leftLim (↑f) x)))

tactic: have h_le1 : ∀ x, f (x - 1) ≤ leftLim f x := fun x => Monotone.le_leftLim f.mono (sub_one_lt x)
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
⊢ Tendsto (fun x => leftLim (↑f) x) atTop (𝓝 l)

tactic: have h_le2 : ∀ x, leftLim f x ≤ f x := fun x => Monotone.leftLim_le f.mono le_rfl
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
h_le1 : ∀ (x : ℝ), ↑f (x - 1) ≤ leftLim (↑f) x
⊢ Tendsto (fun x => leftLim (↑f) x) atTop (𝓝 l)

tactic: refine' tendsto_of_tendsto_of_tendsto_of_le_of_le (hf.comp _) hf h_le1 h_le2
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
h_le1 : ∀ (x : ℝ), ↑f (x - 1) ≤ leftLim (↑f) x
h_le2 : ∀ (x : ℝ), leftLim (↑f) x ≤ ↑f x
⊢ Tendsto (fun x => leftLim (↑f) x) atTop (𝓝 l)

tactic: rw [tendsto_atTop_atTop]
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
h_le1 : ∀ (x : ℝ), ↑f (x - 1) ≤ leftLim (↑f) x
h_le2 : ∀ (x : ℝ), leftLim (↑f) x ≤ ↑f x
⊢ Tendsto (fun i => i - 1) atTop atTop

tactic: exact fun y => ⟨y + 1, fun z hyz => by rwa [le_sub_iff_add_le]⟩
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
h_le1 : ∀ (x : ℝ), ↑f (x - 1) ≤ leftLim (↑f) x
h_le2 : ∀ (x : ℝ), leftLim (↑f) x ≤ ↑f x
⊢ ∀ (b : ℝ), ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a - 1

tactic: rwa [le_sub_iff_add_le]
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atTop (𝓝 l)
x : ℝ
h_le1 : ∀ (x : ℝ), ↑f (x - 1) ≤ leftLim (↑f) x
h_le2 : ∀ (x : ℝ), leftLim (↑f) x ≤ ↑f x
y z : ℝ
hyz : y + 1 ≤ z
⊢ y ≤ z - 1
Theorem: Real.rpow_sum_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: induction' s using Finset.cons_induction with i s hi ihs
state_before: x y z : ℝ
ι : Type u_1
a : ℝ
ha : 0 ≤ a
s : Finset ι
f : ι → ℝ
h : ∀ (x : ι), x ∈ s → 0 ≤ f x
⊢ a ^ ∑ x in s, f x = ∏ x in s, a ^ f x

tactic: rw [sum_empty, Finset.prod_empty, rpow_zero]
state_before: case empty
x y z : ℝ
ι : Type u_1
a : ℝ
ha : 0 ≤ a
s : Finset ι
f : ι → ℝ
h✝ : ∀ (x : ι), x ∈ s → 0 ≤ f x
h : ∀ (x : ι), x ∈ ∅ → 0 ≤ f x
⊢ a ^ ∑ x in ∅, f x = ∏ x in ∅, a ^ f x

tactic: rw [forall_mem_cons] at h
state_before: case cons
x y z : ℝ
ι : Type u_1
a : ℝ
ha : 0 ≤ a
s✝ : Finset ι
f : ι → ℝ
h✝ : ∀ (x : ι), x ∈ s✝ → 0 ≤ f x
i : ι
s : Finset ι
hi : ¬i ∈ s
ihs : (∀ (x : ι), x ∈ s → 0 ≤ f x) → a ^ ∑ x in s, f x = ∏ x in s, a ^ f x
h : ∀ (x : ι), x ∈ cons i s hi → 0 ≤ f x
⊢ a ^ ∑ x in cons i s hi, f x = ∏ x in cons i s hi, a ^ f x

tactic: rw [sum_cons, prod_cons, ← ihs h.2, rpow_add_of_nonneg ha h.1 (sum_nonneg h.2)]
state_before: case cons
x y z : ℝ
ι : Type u_1
a : ℝ
ha : 0 ≤ a
s✝ : Finset ι
f : ι → ℝ
h✝ : ∀ (x : ι), x ∈ s✝ → 0 ≤ f x
i : ι
s : Finset ι
hi : ¬i ∈ s
ihs : (∀ (x : ι), x ∈ s → 0 ≤ f x) → a ^ ∑ x in s, f x = ∏ x in s, a ^ f x
h : 0 ≤ f i ∧ ∀ (x : ι), x ∈ s → 0 ≤ f x
⊢ a ^ ∑ x in cons i s hi, f x = ∏ x in cons i s hi, a ^ f x
Theorem: CategoryTheory.Functor.rightOp_leftOp_eq
File: Mathlib/CategoryTheory/Opposites.lean

tactic: cases F
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : Cᵒᵖ ⥤ D
⊢ F.rightOp.leftOp = F

tactic: rfl
state_before: case mk
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
toPrefunctor✝ : Cᵒᵖ ⥤q D
map_id✝ : ∀ (X : Cᵒᵖ), toPrefunctor✝.map (𝟙 X) = 𝟙 (toPrefunctor✝.obj X)
map_comp✝ :
  ∀ {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z), toPrefunctor✝.map (f ≫ g) = toPrefunctor✝.map f ≫ toPrefunctor✝.map g
⊢ (mk toPrefunctor✝).rightOp.leftOp = mk toPrefunctor✝
Theorem: Real.volume_pi_le_diam_pow
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [ENNReal.coe_one, one_mul, Finset.prod_const, Fintype.card]
state_before: ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
⊢ ∏ _i : ι, ↑1 * EMetric.diam s = EMetric.diam s ^ Fintype.card ι
Theorem: Order.le_succ_iff_eq_or_le
File: Mathlib/Order/SuccPred/Basic.lean

tactic: by_cases hb : IsMax b
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b

tactic: rw [hb.succ_eq, or_iff_right_of_imp le_of_eq]
state_before: case pos
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
hb : IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b

tactic: rw [← lt_succ_iff_of_not_isMax hb, le_iff_eq_or_lt]
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
hb : ¬IsMax b
⊢ a ≤ succ b ↔ a = succ b ∨ a ≤ b
Theorem: Polynomial.X_pow_mul_assoc
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [mul_assoc, X_pow_mul, ← mul_assoc]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ p * X ^ n * q = p * q * X ^ n
Theorem: Matrix.add_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct, add_mul, Finset.sum_add_distrib]
state_before: l : Type ?u.134471
m : Type u_1
n : Type ?u.134477
o : Type ?u.134480
m' : o → Type ?u.134485
n' : o → Type ?u.134490
R : Type ?u.134493
S : Type ?u.134496
α : Type v
β : Type w
γ : Type ?u.134503
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ (u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w
Theorem: Prod.fst_zmod_cast
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
R : Type u_1
inst✝¹ : AddGroupWithOne R
S : Type u_2
inst✝ : AddGroupWithOne S
a : ZMod n
⊢ (↑a).fst = ↑a

tactic: . rfl
state_before: case zero
R : Type u_1
inst✝¹ : AddGroupWithOne R
S : Type u_2
inst✝ : AddGroupWithOne S
a : ZMod Nat.zero
⊢ (↑a).fst = ↑a

case succ
R : Type u_1
inst✝¹ : AddGroupWithOne R
S : Type u_2
inst✝ : AddGroupWithOne S
n✝ : ℕ
a : ZMod (Nat.succ n✝)
⊢ (↑a).fst = ↑a

tactic: . simp [ZMod.cast]
state_before: case succ
R : Type u_1
inst✝¹ : AddGroupWithOne R
S : Type u_2
inst✝ : AddGroupWithOne S
n✝ : ℕ
a : ZMod (Nat.succ n✝)
⊢ (↑a).fst = ↑a

tactic: rfl
state_before: case zero
R : Type u_1
inst✝¹ : AddGroupWithOne R
S : Type u_2
inst✝ : AddGroupWithOne S
a : ZMod Nat.zero
⊢ (↑a).fst = ↑a

tactic: simp [ZMod.cast]
state_before: case succ
R : Type u_1
inst✝¹ : AddGroupWithOne R
S : Type u_2
inst✝ : AddGroupWithOne S
n✝ : ℕ
a : ZMod (Nat.succ n✝)
⊢ (↑a).fst = ↑a
Theorem: Fin.partialProd_left_inv
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp
state_before: α : Type ?u.96916
β : Type ?u.96919
inst✝¹ : Monoid α
n : ℕ
G : Type u_1
inst✝ : Group G
f : Fin (n + 1) → G
x : Fin (n + 1)
⊢ (f 0 • partialProd fun i => (f ↑↑i)⁻¹ * f (succ i)) 0 = f 0

tactic: simp only [coe_eq_castSucc, Pi.smul_apply, smul_eq_mul] at hx⊢
state_before: α : Type ?u.96916
β : Type ?u.96919
inst✝¹ : Monoid α
n : ℕ
G : Type u_1
inst✝ : Group G
f : Fin (n + 1) → G
x✝ : Fin (n + 1)
x : Fin n
hx : (f 0 • partialProd fun i => (f ↑↑i)⁻¹ * f (succ i)) (↑castSucc x) = f (↑castSucc x)
⊢ (f 0 • partialProd fun i => (f ↑↑i)⁻¹ * f (succ i)) (succ x) = f (succ x)

tactic: rw [partialProd_succ, ← mul_assoc, hx, mul_inv_cancel_left]
state_before: α : Type ?u.96916
β : Type ?u.96919
inst✝¹ : Monoid α
n : ℕ
G : Type u_1
inst✝ : Group G
f : Fin (n + 1) → G
x✝ : Fin (n + 1)
x : Fin n
hx : f 0 * partialProd (fun i => (f (↑castSucc i))⁻¹ * f (succ i)) (↑castSucc x) = f (↑castSucc x)
⊢ f 0 * partialProd (fun i => (f (↑castSucc i))⁻¹ * f (succ i)) (succ x) = f (succ x)
Theorem: Set.partiallyWellOrderedOn_iff_exists_monotone_subseq
File: Mathlib/Order/WellFoundedSet.lean

tactic: constructor <;> intro h f hf
state_before: ι : Type ?u.86706
α : Type u_1
β : Type ?u.86712
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
⊢ PartiallyWellOrderedOn s r ↔ ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))

tactic: exact h.exists_monotone_subseq f hf
state_before: case mp
ι : Type ?u.86706
α : Type u_1
β : Type ?u.86712
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
⊢ ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))

tactic: obtain ⟨g, gmon⟩ := h f hf
state_before: case mpr
ι : Type ?u.86706
α : Type u_1
β : Type ?u.86712
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
⊢ ∃ m n, m < n ∧ r (f m) (f n)

tactic: exact ⟨g 0, g 1, g.lt_iff_lt.2 zero_lt_one, gmon _ _ zero_le_one⟩
state_before: case mpr.intro
ι : Type ?u.86706
α : Type u_1
β : Type ?u.86712
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ s) → ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
gmon : ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))
⊢ ∃ m n, m < n ∧ r (f m) (f n)
Theorem: Subtype.preimage_coe_eq_empty
File: Mathlib/Data/Set/Image.lean

tactic: simp [← not_nonempty_iff_eq_empty, preimage_coe_nonempty]
state_before: α : Type u_1
s t : Set α
⊢ val ⁻¹' t = ∅ ↔ s ∩ t = ∅
Theorem: Multiset.Ico_filter_lt
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, Ico, ← Finset.filter_val, Finset.Ico_filter_lt]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
⊢ filter (fun x => x < c) (Ico a b) = Ico a (min b c)
Theorem: convexJoin_right_comm
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp_rw [convexJoin_assoc, convexJoin_comm]
state_before: ι : Sort ?u.70849
𝕜 : Type u_2
E : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ t✝ u✝ : Set E
x y : E
s t u : Set E
⊢ convexJoin 𝕜 (convexJoin 𝕜 s t) u = convexJoin 𝕜 (convexJoin 𝕜 s u) t