tasksource/leandojo huggingface dataset:
Theorem: Matrix.mulVec_one
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.897846
m : Type u_2
n : Type u_1
o : Type ?u.897855
m' : o → Type ?u.897860
n' : o → Type ?u.897865
R : Type ?u.897868
S : Type ?u.897871
α : Type v
β : Type w
γ : Type ?u.897878
inst✝¹ : NonAssocSemiring α
inst✝ : Fintype n
A : Matrix m n α
⊢ mulVec A 1 = fun i => ∑ j : n, A i j

tactic: simp [mulVec, dotProduct]
state_before: case h
l : Type ?u.897846
m : Type u_2
n : Type u_1
o : Type ?u.897855
m' : o → Type ?u.897860
n' : o → Type ?u.897865
R : Type ?u.897868
S : Type ?u.897871
α : Type v
β : Type w
γ : Type ?u.897878
inst✝¹ : NonAssocSemiring α
inst✝ : Fintype n
A : Matrix m n α
x✝ : m
⊢ mulVec A 1 x✝ = ∑ j : n, A x✝ j
Theorem: Nat.gcd_add_mul_left_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: simp [gcd_rec m (n + m * k), gcd_rec m n]
state_before: m n k : ℕ
⊢ gcd m (n + m * k) = gcd m n
Theorem: CircleDeg1Lift.pow_mono
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [coe_pow, iterate_mono h n x]
state_before: f✝ g✝ f g : CircleDeg1Lift
h : f ≤ g
n : ℕ
x : ℝ
⊢ ↑(f ^ n) x ≤ ↑(g ^ n) x
Theorem: div_mul_div_cancel
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: rw [← mul_div_assoc, div_mul_cancel _ hc]
state_before: α : Type ?u.8508
M₀ : Type ?u.8511
G₀ : Type u_1
M₀' : Type ?u.8517
G₀' : Type ?u.8520
F : Type ?u.8523
F' : Type ?u.8526
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
hc : c ≠ 0
⊢ a / c * (c / b) = a / b
Theorem: Polynomial.Monic.sub_of_left
File: Mathlib/Data/Polynomial/Monic.lean

tactic: rw [sub_eq_add_neg]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : Monic p
hpq : degree q < degree p
⊢ Monic (p - q)

tactic: apply hp.add_of_left
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : Monic p
hpq : degree q < degree p
⊢ Monic (p + -q)

tactic: rwa [degree_neg]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Ring R
p✝ p q : R[X]
hp : Monic p
hpq : degree q < degree p
⊢ degree (-q) < degree p
Theorem: StateT.run_map
File: src/lean/Init/Control/Lawful.lean

tactic: simp [Functor.map, StateT.map, run, map_eq_pure_bind]
state_before: m : Type u → Type u_1
α β σ : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β
x : StateT σ m α
s : σ
⊢ run (f <$> x) s = (fun p => (f p.fst, p.snd)) <$> run x s
Theorem: Polynomial.C_mul_dvd
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [mul_assoc, mul_left_comm p, ← mul_assoc, ← C.map_mul, _root_.mul_inv_cancel ha, C.map_one,
  one_mul, hr]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
ha : a ≠ 0
x✝ : p ∣ q
r : R[X]
hr : q = p * r
⊢ q = ↑C a * p * (↑C a⁻¹ * r)
Theorem: PowerSeries.order_eq
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: induction n using PartENat.casesOn
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n : PartENat
⊢ order φ = n ↔ (∀ (i : ℕ), ↑i = n → ↑(coeff R i) φ ≠ 0) ∧ ∀ (i : ℕ), ↑i < n → ↑(coeff R i) φ = 0

tactic: rw [order_eq_top]
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ order φ = ⊤ ↔ (∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) φ ≠ 0) ∧ ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0

tactic: constructor
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ φ = 0 ↔ (∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) φ ≠ 0) ∧ ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0

tactic: rintro rfl
state_before: case a.mp
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ φ = 0 → (∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) φ ≠ 0) ∧ ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0

tactic: constructor <;> intros
state_before: case a.mp
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
⊢ (∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) 0 ≠ 0) ∧ ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) 0 = 0

tactic: exfalso
state_before: case a.mp.left
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
i✝ : ℕ
a✝ : ↑i✝ = ⊤
⊢ ↑(coeff R i✝) 0 ≠ 0

tactic: exact PartENat.natCast_ne_top ‹_› ‹_›
state_before: case a.mp.left.h
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
i✝ : ℕ
a✝ : ↑i✝ = ⊤
⊢ False

tactic: exact (coeff _ _).map_zero
state_before: case a.mp.right
R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
i✝ : ℕ
a✝ : ↑i✝ < ⊤
⊢ ↑(coeff R i✝) 0 = 0

tactic: rintro ⟨_h₁, h₂⟩
state_before: case a.mpr
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
⊢ ((∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) φ ≠ 0) ∧ ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0) → φ = 0

tactic: ext i
state_before: case a.mpr.intro
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
_h₁ : ∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) φ ≠ 0
h₂ : ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0
⊢ φ = 0

tactic: exact h₂ i (PartENat.natCast_lt_top i)
state_before: case a.mpr.intro.h
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
_h₁ : ∀ (i : ℕ), ↑i = ⊤ → ↑(coeff R i) φ ≠ 0
h₂ : ∀ (i : ℕ), ↑i < ⊤ → ↑(coeff R i) φ = 0
i : ℕ
⊢ ↑(coeff R i) φ = ↑(coeff R i) 0

tactic: simpa [PartENat.natCast_inj] using order_eq_nat
state_before: case a
R : Type u_1
inst✝ : Semiring R
φ✝ φ : PowerSeries R
n✝ : ℕ
⊢ order φ = ↑n✝ ↔ (∀ (i : ℕ), ↑i = ↑n✝ → ↑(coeff R i) φ ≠ 0) ∧ ∀ (i : ℕ), ↑i < ↑n✝ → ↑(coeff R i) φ = 0
Theorem: ZMod.coe_valMinAbs
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [valMinAbs_def_pos]
state_before: k n : ℕ
h✝ : k = n + 1
x : ZMod (namedPattern k (n + 1) h✝)
⊢ ↑(valMinAbs x) = x

tactic: split_ifs
state_before: k n : ℕ
h✝ : k = n + 1
x : ZMod (namedPattern k (n + 1) h✝)
⊢ ↑(if val x ≤ namedPattern k (n + 1) h✝ / 2 then ↑(val x) else ↑(val x) - ↑(namedPattern k (n + 1) h✝)) = x

tactic: rw [Int.cast_ofNat, nat_cast_zmod_val]
state_before: case inl
k n : ℕ
h✝¹ : k = n + 1
x : ZMod (namedPattern k (n + 1) h✝¹)
h✝ : val x ≤ namedPattern k (n + 1) h✝¹ / 2
⊢ ↑↑(val x) = x

tactic: rw [Int.cast_sub, Int.cast_ofNat, nat_cast_zmod_val, Int.cast_ofNat, nat_cast_self, sub_zero]
state_before: case inr
k n : ℕ
h✝¹ : k = n + 1
x : ZMod (namedPattern k (n + 1) h✝¹)
h✝ : ¬val x ≤ namedPattern k (n + 1) h✝¹ / 2
⊢ ↑(↑(val x) - ↑(namedPattern k (n + 1) h✝¹)) = x
Theorem: Finmap.keys_ext
File: Mathlib/Data/Finmap.lean

tactic: simp [keys, AList.keys]
state_before: α : Type u
β : α → Type v
s₁ s₂ : AList β
⊢ keys ⟦s₁⟧ = keys ⟦s₂⟧ ↔ AList.keys s₁ ~ AList.keys s₂
Theorem: Set.PartiallyWellOrderedOn.wellFoundedOn
File: Mathlib/Order/WellFoundedSet.lean

tactic: letI : Preorder α :=
  { le := r
    le_refl := refl_of r
    le_trans := fun _ _ _ => trans_of r }
state_before: ι : Type ?u.95097
α : Type u_1
β : Type ?u.95103
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
inst✝ : IsPreorder α r
h : PartiallyWellOrderedOn s r
⊢ WellFoundedOn s fun a b => r a b ∧ ¬r b a

tactic: rw [wellFoundedOn_iff_no_descending_seq]
state_before: ι : Type ?u.95097
α : Type u_1
β : Type ?u.95103
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
inst✝ : IsPreorder α r
this : Preorder α := Preorder.mk (_ : ∀ (a : α), r a a) (_ : ∀ (x x_1 x_2 : α), r x x_1 → r x_1 x_2 → r x x_2)
h : PartiallyWellOrderedOn s fun x x_1 => x ≤ x_1
⊢ WellFoundedOn s fun x x_1 => x < x_1

tactic: intro f hf
state_before: ι : Type ?u.95097
α : Type u_1
β : Type ?u.95103
r : α → α → Prop
r' : β → β → Prop
f : α → β
s t : Set α
a : α
inst✝ : IsPreorder α r
this : Preorder α := Preorder.mk (_ : ∀ (a : α), r a a) (_ : ∀ (x x_1 x_2 : α), r x x_1 → r x_1 x_2 → r x x_2)
h : PartiallyWellOrderedOn s fun x x_1 => x ≤ x_1
⊢ ∀ (f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x < x_1), ¬∀ (n : ℕ), ↑f n ∈ s

tactic: obtain ⟨m, n, hlt, hle⟩ := h f hf
state_before: ι : Type ?u.95097
α : Type u_1
β : Type ?u.95103
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝ : IsPreorder α r
this : Preorder α := Preorder.mk (_ : ∀ (a : α), r a a) (_ : ∀ (x x_1 x_2 : α), r x x_1 → r x_1 x_2 → r x x_2)
h : PartiallyWellOrderedOn s fun x x_1 => x ≤ x_1
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x < x_1
hf : ∀ (n : ℕ), ↑f n ∈ s
⊢ False

tactic: exact (f.map_rel_iff.2 hlt).not_le hle
state_before: case intro.intro.intro
ι : Type ?u.95097
α : Type u_1
β : Type ?u.95103
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝ : IsPreorder α r
this : Preorder α := Preorder.mk (_ : ∀ (a : α), r a a) (_ : ∀ (x x_1 x_2 : α), r x x_1 → r x_1 x_2 → r x x_2)
h : PartiallyWellOrderedOn s fun x x_1 => x ≤ x_1
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x < x_1
hf : ∀ (n : ℕ), ↑f n ∈ s
m n : ℕ
hlt : m < n
hle : ↑f m ≤ ↑f n
⊢ False
Theorem: Subalgebra.iSupLift_inclusion
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: dsimp [iSupLift, inclusion]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_1
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → { x // x ∈ K i } →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = AlgHom.comp (f j) (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : { x // x ∈ K i }
h : K i ≤ T
⊢ ↑(iSupLift K dir f hf T hT) (↑(inclusion h) x) = ↑(f i) x

tactic: rw [Set.iUnionLift_inclusion]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_1
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → { x // x ∈ K i } →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = AlgHom.comp (f j) (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : { x // x ∈ K i }
h : K i ≤ T
⊢ Set.iUnionLift (fun i => ↑(K i)) (fun i x => ↑(f i) x)
      (_ :
        ∀ (i j : ι) (x : A) (hxi : x ∈ (fun i => ↑(K i)) i) (hxj : x ∈ (fun i => ↑(K i)) j),
          (fun i x => ↑(f i) x) i { val := x, property := hxi } = (fun i x => ↑(f i) x) j { val := x, property := hxj })
      ↑T (_ : ↑T ⊆ ⋃ (i : ι), ↑(K i)) (Set.inclusion h x) =
    ↑(f i) x
Theorem: Set.LeftInvOn.image_inter'
File: Mathlib/Data/Set/Function.lean

tactic: apply Subset.antisymm
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f '' (s₁ ∩ s) = f' ⁻¹' s₁ ∩ f '' s

tactic: rintro _ ⟨x, ⟨h₁, h⟩, rfl⟩
state_before: case h₁
α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f '' (s₁ ∩ s) ⊆ f' ⁻¹' s₁ ∩ f '' s

tactic: exact ⟨by rwa [mem_preimage, hf h], mem_image_of_mem _ h⟩
state_before: case h₁.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
x : α
h₁ : x ∈ s₁
h : x ∈ s
⊢ f x ∈ f' ⁻¹' s₁ ∩ f '' s

tactic: rwa [mem_preimage, hf h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
x : α
h₁ : x ∈ s₁
h : x ∈ s
⊢ f x ∈ f' ⁻¹' s₁

tactic: rintro _ ⟨h₁, ⟨x, h, rfl⟩⟩
state_before: case h₂
α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f' ⁻¹' s₁ ∩ f '' s ⊆ f '' (s₁ ∩ s)

tactic: exact mem_image_of_mem _ ⟨by rwa [← hf h], h⟩
state_before: case h₂.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
x : α
h : x ∈ s
h₁ : f x ∈ f' ⁻¹' s₁
⊢ f x ∈ f '' (s₁ ∩ s)

tactic: rwa [← hf h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59103
ι : Sort ?u.59106
π : α → Type ?u.59111
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
x : α
h : x ∈ s
h₁ : f x ∈ f' ⁻¹' s₁
⊢ x ∈ s₁
Theorem: PrimeSpectrum.zeroLocus_singleton_mul
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simpa using x.2.mul_mem_iff_mem_or_mem
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f g : R
x : PrimeSpectrum R
⊢ x ∈ zeroLocus {f * g} ↔ x ∈ zeroLocus {f} ∪ zeroLocus {g}
Theorem: Ordinal.sub_isLimit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rwa [add_zero]
state_before: α : Type ?u.133611
β : Type ?u.133614
γ : Type ?u.133617
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
l : IsLimit a
h : b < a
⊢ b + 0 < a

tactic: rw [lt_sub, add_succ]
state_before: α : Type ?u.133611
β : Type ?u.133614
γ : Type ?u.133617
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
l : IsLimit a
h✝ : b < a
c : Ordinal
h : c < a - b
⊢ succ c < a - b

tactic: exact l.2 _ (lt_sub.1 h)
state_before: α : Type ?u.133611
β : Type ?u.133614
γ : Type ?u.133617
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
l : IsLimit a
h✝ : b < a
c : Ordinal
h : c < a - b
⊢ succ (b + c) < a
Theorem: SimpleGraph.isBridge_iff_adj_and_forall_walk_mem_edges
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [isBridge_iff, and_congr_right']
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ IsBridge G (Quotient.mk (Sym2.Rel.setoid V) (v, w)) ↔
    Adj G v w ∧ ∀ (p : Walk G v w), Quotient.mk (Sym2.Rel.setoid V) (v, w) ∈ Walk.edges p

tactic: rw [reachable_delete_edges_iff_exists_walk, not_exists_not]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ ¬Reachable (G \ fromEdgeSet {Quotient.mk (Sym2.Rel.setoid V) (v, w)}) v w ↔
    ∀ (p : Walk G v w), Quotient.mk (Sym2.Rel.setoid V) (v, w) ∈ Walk.edges p
Theorem: Nat.base_pow_length_digits_le
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases b with (_ | _ | b) <;> try simp_all
state_before: n b m : ℕ
hb : 1 < b
⊢ m ≠ 0 → b ^ List.length (digits b m) ≤ b * m

tactic: exact base_pow_length_digits_le' b m
state_before: case succ.succ
n m b : ℕ
⊢ ¬m = 0 → succ (succ b) ^ List.length (digits (succ (succ b)) m) ≤ succ (succ b) * m

tactic: simp_all
state_before: case succ.succ
n m b : ℕ
hb : 1 < succ (succ b)
⊢ m ≠ 0 → succ (succ b) ^ List.length (digits (succ (succ b)) m) ≤ succ (succ b) * m
Theorem: tendsto_self_mul_const_pow_of_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simpa only [pow_one] using tendsto_pow_const_mul_const_pow_of_lt_one 1 hr h'r
state_before: α : Type ?u.130031
β : Type ?u.130034
ι : Type ?u.130037
r : ℝ
hr : 0 ≤ r
h'r : r < 1
⊢ Tendsto (fun n => ↑n * r ^ n) atTop (𝓝 0)
Theorem: CompositionSeries.bot_snoc
File: Mathlib/Order/JordanHolder.lean

tactic: rw [bot, bot, ← snoc_castSucc s _ _ 0, Fin.castSucc_zero]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
x : X
hsat : IsMaximal (top s) x
⊢ bot (snoc s x hsat) = bot s
Theorem: edist_ne_top_of_mem_ball
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [edist_comm a x, edist_comm a y]
state_before: α : Type ?u.350406
β : Type u_1
γ : Type ?u.350412
inst✝ : EMetricSpace β
a : β
r : ℝ≥0∞
x y : ↑(EMetric.ball a r)
⊢ edist a ↑x + edist a ↑y < r + r

tactic: exact add_lt_add x.2 y.2
state_before: α : Type ?u.350406
β : Type u_1
γ : Type ?u.350412
inst✝ : EMetricSpace β
a : β
r : ℝ≥0∞
x y : ↑(EMetric.ball a r)
⊢ edist (↑x) a + edist (↑y) a < r + r
Theorem: List.dropLast_append_of_ne_nil
File: Mathlib/Data/List/Basic.lean

tactic: simp only [nil_append]
state_before: ι : Type ?u.198199
α✝ : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
l : List α
x✝ : l ≠ []
⊢ dropLast ([] ++ l) = [] ++ dropLast l

tactic: rw [cons_append, dropLast, dropLast_append_of_ne_nil l' h, cons_append]
state_before: ι : Type ?u.198199
α✝ : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
l : List α
a : α
l' : List α
h : l ≠ []
⊢ dropLast (a :: l' ++ l) = a :: l' ++ dropLast l

tactic: simp [h]
state_before: case x_2
ι : Type ?u.198199
α✝ : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
l : List α
a : α
l' : List α
h : l ≠ []
⊢ l' ++ l = [] → False
Theorem: Matrix.conjTranspose_rat_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.1036039
m : Type u_1
n : Type u_2
o : Type ?u.1036048
m' : o → Type ?u.1036053
n' : o → Type ?u.1036058
R : Type ?u.1036061
S : Type ?u.1036064
α : Type v
β : Type w
γ : Type ?u.1036071
inst✝² : AddCommGroup α
inst✝¹ : StarAddMonoid α
inst✝ : Module ℚ α
c : ℚ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (c • M)ᴴ i j = (c • Mᴴ) i j
Theorem: Filter.tendsto_inf
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Tendsto, le_inf_iff, iff_self_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.313910
ι : Sort x
f : α → β
x : Filter α
y₁ y₂ : Filter β
⊢ Tendsto f x (y₁ ⊓ y₂) ↔ Tendsto f x y₁ ∧ Tendsto f x y₂
Theorem: MulHom.map_srange
File: Mathlib/GroupTheory/Subsemigroup/Operations.lean

tactic: simpa only [srange_eq_map] using (⊤ : Subsemigroup M).map_map g f
state_before: M : Type u_3
N : Type u_1
P : Type u_2
σ : Type ?u.60762
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
g : N →ₙ* P
f : M →ₙ* N
⊢ map g (srange f) = srange (comp g f)
Theorem: Mathlib.Tactic.Ring.smul_nat
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type ?u.195256
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b c : ℕ
x✝ : a * b = c
⊢ a • b = c

tactic: simp
state_before: u : Lean.Level
R : Type ?u.195256
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b : ℕ
⊢ a • b = a * b
Theorem: CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [pushoutZeroZeroIso]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ pushout.inr ≫ (pushoutZeroZeroIso X Y).hom = coprod.inr

tactic: simp
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ pushout.inr ≫
      (colimit.isoColimitCocone
          { cocone := PushoutCocone.mk coprod.inl coprod.inr (_ : 0 ≫ coprod.inl = 0 ≫ coprod.inr),
            isColimit :=
              isPushoutOfIsInitialIsCoproduct coprod.inl coprod.inr 0 0 HasZeroObject.zeroIsInitial
                (coprodIsCoprod X Y) }).hom =
    coprod.inr
Theorem: Finset.uIcc_comm
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [uIcc, uIcc, inf_comm, sup_comm]
state_before: ι : Type ?u.174713
α : Type u_1
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c x a b : α
⊢ [[a, b]] = [[b, a]]
Theorem: exists_one_lt_mul_of_lt
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: obtain ⟨c, hc⟩ := le_iff_exists_mul.1 h.le
state_before: α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
h : a < b
⊢ ∃ c x, a * c = b

tactic: refine' ⟨c, one_lt_iff_ne_one.2 _, hc.symm⟩
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c✝ d : α
h : a < b
c : α
hc : b = a * c
⊢ ∃ c x, a * c = b

tactic: rintro rfl
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c✝ d : α
h : a < b
c : α
hc : b = a * c
⊢ c ≠ 1

tactic: simp [hc, lt_irrefl] at h
state_before: case intro
α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
h : a < b
hc : b = a * 1
⊢ False
Theorem: Function.Periodic.comp
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝ : Add α
h : Periodic f c
g : β → γ
⊢ Periodic (g ∘ f) c
Theorem: mem_comp_comp
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: cases' p with x y
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
p : β × β
⊢ p ∈ V ○ M ○ W ↔ Set.Nonempty (ball p.fst V ×ˢ ball p.snd W ∩ M)

tactic: constructor
state_before: case mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ (x, y) ∈ V ○ M ○ W ↔ Set.Nonempty (ball (x, y).fst V ×ˢ ball (x, y).snd W ∩ M)

tactic: rintro ⟨z, ⟨w, hpw, hwz⟩, hzy⟩
state_before: case mk.mp
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ (x, y) ∈ V ○ M ○ W → Set.Nonempty (ball (x, y).fst V ×ˢ ball (x, y).snd W ∩ M)

tactic: exact ⟨(w, z), ⟨hpw, by rwa [mem_ball_symmetry hW']⟩, hwz⟩
state_before: case mk.mp.intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y z : β
hzy : (z, (x, y).snd) ∈ W
w : β
hpw : (((x, y).fst, z).fst, w) ∈ V
hwz : (w, ((x, y).fst, z).snd) ∈ M
⊢ Set.Nonempty (ball (x, y).fst V ×ˢ ball (x, y).snd W ∩ M)

tactic: rwa [mem_ball_symmetry hW']
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y z : β
hzy : (z, (x, y).snd) ∈ W
w : β
hpw : (((x, y).fst, z).fst, w) ∈ V
hwz : (w, ((x, y).fst, z).snd) ∈ M
⊢ (w, z).snd ∈ ball (x, y).snd W

tactic: rintro ⟨⟨w, z⟩, ⟨w_in, z_in⟩, hwz⟩
state_before: case mk.mpr
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y : β
⊢ Set.Nonempty (ball (x, y).fst V ×ˢ ball (x, y).snd W ∩ M) → (x, y) ∈ V ○ M ○ W

tactic: rw [mem_ball_symmetry hW'] at z_in
state_before: case mk.mpr.intro.mk.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y w z : β
hwz : (w, z) ∈ M
w_in : (w, z).fst ∈ ball (x, y).fst V
z_in : (w, z).snd ∈ ball (x, y).snd W
⊢ (x, y) ∈ V ○ M ○ W

tactic: exact ⟨z, ⟨w, w_in, hwz⟩, z_in⟩
state_before: case mk.mpr.intro.mk.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.56107
inst✝ : UniformSpace α
V W M : Set (β × β)
hW' : SymmetricRel W
x y w z : β
hwz : (w, z) ∈ M
w_in : (w, z).fst ∈ ball (x, y).fst V
z_in : (x, y).snd ∈ ball (w, z).snd W
⊢ (x, y) ∈ V ○ M ○ W
Theorem: Ideal.Filtration.inf_submodule
File: Mathlib/RingTheory/Filtration.lean

tactic: ext
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
⊢ Filtration.submodule (F ⊓ F') = Filtration.submodule F ⊓ Filtration.submodule F'

tactic: exact forall_and
state_before: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
x✝ : PolynomialModule R M
⊢ x✝ ∈ Filtration.submodule (F ⊓ F') ↔ x✝ ∈ Filtration.submodule F ⊓ Filtration.submodule F'
Theorem: List.sigma_nil
File: Mathlib/Data/List/ProdSigma.lean

tactic: simp [sigma_cons, sigma_nil]
state_before: α : Type u_1
β : Type ?u.7878
σ : α → Type u_2
head✝ : α
l : List α
⊢ (List.sigma (head✝ :: l) fun a => []) = []
Theorem: Filter.HasBasis.lift'
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [exists_const, true_and, comp]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.28763
ι✝ : Sort ?u.28766
f f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
ι : Sort u_1
p : ι → Prop
s : ι → Set α
hf : HasBasis f p s
hh : Monotone h
t : Set β
⊢ (∃ i, p i ∧ ∃ x, True ∧ h (s i) ⊆ t) ↔ ∃ i, p i ∧ (h ∘ s) i ⊆ t
Theorem: iInf_pair
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iInf_insert, iInf_singleton]
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.142048
γ : Type ?u.142051
ι : Sort ?u.142054
ι' : Sort ?u.142057
κ : ι → Sort ?u.142062
κ' : ι' → Sort ?u.142067
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b✝ : α
f : β → α
a b : β
⊢ (⨅ (x : β) (_ : x ∈ {a, b}), f x) = f a ⊓ f b