tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.rename_monomial
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: rw [rename, aeval_monomial, monomial_eq (s := Finsupp.mapDomain f d),
  Finsupp.prod_mapDomain_index]
state_before: σ : Type u_1
τ : Type u_2
α : Type ?u.227167
R : Type u_3
S : Type ?u.227173
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ↑(rename f) (↑(monomial d) r) = ↑(monomial (Finsupp.mapDomain f d)) r

tactic: rfl
state_before: σ : Type u_1
τ : Type u_2
α : Type ?u.227167
R : Type u_3
S : Type ?u.227173
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ (↑(algebraMap R (MvPolynomial τ R)) r * Finsupp.prod d fun i k => (X ∘ f) i ^ k) =
    ↑C r * Finsupp.prod d fun a m => X (f a) ^ m

tactic: exact fun n => pow_zero _
state_before: case h_zero
σ : Type u_1
τ : Type u_2
α : Type ?u.227167
R : Type u_3
S : Type ?u.227173
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ), X b ^ 0 = 1

tactic: exact fun n i₁ i₂ => pow_add _ _ _
state_before: case h_add
σ : Type u_1
τ : Type u_2
α : Type ?u.227167
R : Type u_3
S : Type ?u.227173
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ) (m₁ m₂ : ℕ), X b ^ (m₁ + m₂) = X b ^ m₁ * X b ^ m₂
Theorem: QuotientGroup.card_preimage_mk
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [← Fintype.card_prod, Fintype.card_congr (preimageMkEquivSubgroupProdSet _ _)]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
s : Subgroup G
t : Set (G ⧸ s)
⊢ Fintype.card ↑(mk ⁻¹' t) = Fintype.card { x // x ∈ s } * Fintype.card ↑t
Theorem: Set.eqOn_piecewise
File: Mathlib/Data/Set/Function.lean

tactic: simp only [EqOn, ← forall_and]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.85260
ι : Sort ?u.85263
π : α → Type ?u.85268
δ : α → Sort ?u.85273
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f f' g : α → β
t : Set α
⊢ EqOn (piecewise s f f') g t ↔ EqOn f g (t ∩ s) ∧ EqOn f' g (t ∩ sᶜ)

tactic: refine' forall_congr' fun a => _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.85260
ι : Sort ?u.85263
π : α → Type ?u.85268
δ : α → Sort ?u.85273
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f f' g : α → β
t : Set α
⊢ (∀ ⦃x : α⦄, x ∈ t → piecewise s f f' x = g x) ↔ ∀ (x : α), (x ∈ t ∩ s → f x = g x) ∧ (x ∈ t ∩ sᶜ → f' x = g x)

tactic: by_cases a ∈ s <;> simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.85260
ι : Sort ?u.85263
π : α → Type ?u.85268
δ : α → Sort ?u.85273
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f f' g : α → β
t : Set α
a : α
⊢ a ∈ t → piecewise s f f' a = g a ↔ (a ∈ t ∩ s → f a = g a) ∧ (a ∈ t ∩ sᶜ → f' a = g a)
Theorem: IsROrC.conj_eq_iff_real
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [eq_comm]
state_before: K : Type u_1
E : Type ?u.3717020
inst✝ : IsROrC K
z : K
⊢ (∃ r, ↑r = z) ↔ ∃ r, z = ↑r
Theorem: FreeAlgebra.quot_mk_eq_ι
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [ι_def]
state_before: R : Type u_1
inst✝ : CommSemiring R
X : Type u_2
m : X
⊢ Quot.mk (Rel R X) (Pre.of m) = ι R m
Theorem: EckmannHilton.mul_comm
File: Mathlib/GroupTheory/EckmannHilton.lean

tactic: simpa [mul h₁ h₂ distrib, h₂.left_id, h₂.right_id] using distrib e₂ a b e₂
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b : X
⊢ m₂ a b = m₂ b a
Theorem: AddCommGroup.modEq_zero
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, sub_eq_zero, eq_comm]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ a ≡ b [PMOD 0] ↔ a = b
Theorem: RatFunc.liftOn'_mk
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [RatFunc.liftOn', RatFunc.liftOn_mk _ _ _ f0]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ RatFunc.liftOn' (RatFunc.mk p q) f H = f p q

tactic: apply lift_on_condition_of_lift_on'_condition H
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
Theorem: OrderIso.isBoundedUnder_le_comp
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [eventually_map, e.le_iff_le]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.36752
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
l : Filter γ
u : γ → α
a : α
⊢ (∀ᶠ (x : β) in map (fun x => ↑e (u x)) l, (fun x x_1 => x ≤ x_1) x (↑e a)) ↔
    ∀ᶠ (x : α) in map u l, (fun x x_1 => x ≤ x_1) x a
Theorem: Multiset.nodup_powerset
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp only [quot_mk_to_coe, powerset_coe', coe_nodup]
state_before: α : Type u_1
s : Multiset α
l : List α
h : Nodup (Quotient.mk (isSetoid α) l)
⊢ Nodup (powerset (Quotient.mk (isSetoid α) l))

tactic: refine' (nodup_sublists'.2 h).map_on _
state_before: α : Type u_1
s : Multiset α
l : List α
h : Nodup (Quotient.mk (isSetoid α) l)
⊢ List.Nodup (List.map ofList (sublists' l))

tactic: exact fun x sx y sy e =>
  (h.sublist_ext (mem_sublists'.1 sx) (mem_sublists'.1 sy)).1 (Quotient.exact e)
state_before: α : Type u_1
s : Multiset α
l : List α
h : Nodup (Quotient.mk (isSetoid α) l)
⊢ ∀ (x : List α), x ∈ sublists' l → ∀ (y : List α), y ∈ sublists' l → ↑x = ↑y → x = y
Theorem: WithZeroTopology.isOpen_iff
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
state_before: α : Type ?u.86003
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ IsOpen s ↔ ¬0 ∈ s ∨ ∃ γ, γ ≠ 0 ∧ Iio γ ⊆ s

tactic: simp (config := { contextual := true }) [nhds_of_ne_zero, imp_iff_not_or,
  hasBasis_nhds_zero.mem_iff]
state_before: α : Type ?u.86003
Γ₀ : Type u_1
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ ((0 ∈ s → s ∈ 𝓝 0) ∧ ∀ (b : Γ₀), b ≠ 0 → b ∈ s → s ∈ 𝓝 b) ↔ ¬0 ∈ s ∨ ∃ γ, γ ≠ 0 ∧ Iio γ ⊆ s
Theorem: LinearRecurrence.mkSol_eq_init
File: Mathlib/Algebra/LinearRecurrence.lean

tactic: intro n
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
⊢ ∀ (n : Fin E.order), mkSol E init ↑n = init n

tactic: rw [mkSol]
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : Fin E.order
⊢ mkSol E init ↑n = init n

tactic: simp only [n.is_lt, dif_pos, Fin.mk_val, Fin.eta]
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : Fin E.order
⊢ (if h : ↑n < E.order then init { val := ↑n, isLt := h }
    else
      ∑ k : Fin E.order,
        let_fun x := (_ : ↑n - E.order + ↑k < ↑n);
        coeffs E k * mkSol E init (↑n - E.order + ↑k)) =
    init n
Theorem: Filter.map₂_map_left
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [← map_prod_eq_map₂, ← map_prod_eq_map₂, ← @map_id _ g, prod_map_map_eq, map_map, map_id]
state_before: α : Type u_4
α' : Type ?u.36407
β : Type u_3
β' : Type ?u.36413
γ : Type u_2
γ' : Type ?u.36419
δ : Type u_1
δ' : Type ?u.36425
ε : Type ?u.36428
ε' : Type ?u.36431
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 : α → γ
⊢ map₂ m (map n f) g = map₂ (fun a b => m (n a) b) f g

tactic: rfl
state_before: α : Type u_4
α' : Type ?u.36407
β : Type u_3
β' : Type ?u.36413
γ : Type u_2
γ' : Type ?u.36419
δ : Type u_1
δ' : Type ?u.36425
ε : Type ?u.36428
ε' : Type ?u.36431
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 : α → γ
⊢ map ((fun p => m p.fst p.snd) ∘ fun p => (n p.fst, id p.snd)) (f ×ˢ g) = map (fun p => m (n p.fst) p.snd) (f ×ˢ g)
Theorem: AddMonoid.isTorsion_iff_isTorsion_int
File: Mathlib/Algebra/Module/Torsion.lean

tactic: refine' ⟨fun h x => _, fun h x => _⟩
state_before: R : Type ?u.756570
M : Type u_1
inst✝ : AddCommGroup M
⊢ IsTorsion M ↔ Module.IsTorsion ℤ M

tactic: obtain ⟨n, h0, hn⟩ := (isOfFinAddOrder_iff_nsmul_eq_zero x).mp (h x)
state_before: case refine'_1
R : Type ?u.756570
M : Type u_1
inst✝ : AddCommGroup M
h : IsTorsion M
x : M
⊢ ∃ a, a • x = 0

tactic: exact
  ⟨⟨n, mem_nonZeroDivisors_of_ne_zero <| ne_of_gt <| Int.coe_nat_pos.mpr h0⟩,
    (coe_nat_zsmul _ _).trans hn⟩
state_before: case refine'_1.intro.intro
R : Type ?u.756570
M : Type u_1
inst✝ : AddCommGroup M
h : IsTorsion M
x : M
n : ℕ
h0 : 0 < n
hn : n • x = 0
⊢ ∃ a, a • x = 0

tactic: rw [isOfFinAddOrder_iff_nsmul_eq_zero]
state_before: case refine'_2
R : Type ?u.756570
M : Type u_1
inst✝ : AddCommGroup M
h : Module.IsTorsion ℤ M
x : M
⊢ IsOfFinAddOrder x

tactic: obtain ⟨n, hn⟩ := @h x
state_before: case refine'_2
R : Type ?u.756570
M : Type u_1
inst✝ : AddCommGroup M
h : Module.IsTorsion ℤ M
x : M
⊢ ∃ n, 0 < n ∧ n • x = 0

tactic: exact exists_nsmul_eq_zero_of_zsmul_eq_zero (nonZeroDivisors.coe_ne_zero n) hn
state_before: case refine'_2.intro
R : Type ?u.756570
M : Type u_1
inst✝ : AddCommGroup M
h : Module.IsTorsion ℤ M
x : M
n : { x // x ∈ ℤ⁰ }
hn : n • x = 0
⊢ ∃ n, 0 < n ∧ n • x = 0
Theorem: lp.inner_single_right
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simpa [inner_conj_symm] using congr_arg conj (@inner_single_left _ 𝕜 _ _ _ _ i a f)
state_before: ι : Type u_1
𝕜 : Type u_3
inst✝⁴ : IsROrC 𝕜
E : Type ?u.335242
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_2
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
i : ι
a : G i
f : { x // x ∈ lp G 2 }
⊢ inner f (lp.single 2 i a) = inner (↑f i) a
Theorem: HasDerivAtFilter.add
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa using (hf.add hg).hasDerivAtFilter
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasDerivAtFilter f f' x L
hg : HasDerivAtFilter g g' x L
⊢ HasDerivAtFilter (fun y => f y + g y) (f' + g') x L
Theorem: Bitvec.toFin_le_toFin_of_le
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: rw [toFin_val, toFin_val]
state_before: n : ℕ
v₀ v₁ : Bitvec n
h : v₀ ≤ v₁
⊢ ↑(toFin v₀) ≤ ↑(toFin v₁)

tactic: exact h
state_before: n : ℕ
v₀ v₁ : Bitvec n
h : v₀ ≤ v₁
⊢ Bitvec.toNat v₀ ≤ Bitvec.toNat v₁
Theorem: Equiv.Perm.toList_formPerm_singleton
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ x y : α
⊢ toList (formPerm [x]) y = []
Theorem: IsDedekindDomainInv.isNoetherianRing
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: refine' isNoetherianRing_iff.mpr ⟨fun I : Ideal A => _⟩
state_before: R : Type ?u.127506
A : Type u_1
K : Type ?u.127512
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
⊢ IsNoetherianRing A

tactic: by_cases hI : I = ⊥
state_before: R : Type ?u.127506
A : Type u_1
K : Type ?u.127512
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
⊢ Submodule.FG I

tactic: have hI : (I : FractionalIdeal A⁰ (FractionRing A)) ≠ 0 := coeIdeal_ne_zero.mpr hI
state_before: case neg
R : Type ?u.127506
A : Type u_1
K : Type ?u.127512
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : ¬I = ⊥
⊢ Submodule.FG I

tactic: exact I.fg_of_isUnit (IsFractionRing.injective A (FractionRing A)) (h.isUnit hI)
state_before: case neg
R : Type ?u.127506
A : Type u_1
K : Type ?u.127512
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI✝ : ¬I = ⊥
hI : ↑I ≠ 0
⊢ Submodule.FG I

tactic: rw [hI]
state_before: case pos
R : Type ?u.127506
A : Type u_1
K : Type ?u.127512
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : I = ⊥
⊢ Submodule.FG I

tactic: apply Submodule.fg_bot
state_before: case pos
R : Type ?u.127506
A : Type u_1
K : Type ?u.127512
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : IsDedekindDomainInv A
I : Ideal A
hI : I = ⊥
⊢ Submodule.FG ⊥
Theorem: Int.div_eq_ediv
File: Std/Data/Int/DivMod.lean

tactic: simp
state_before: x✝² : Int
x✝¹ : 0 ≤ x✝²
x✝ : 0 ≤ 0
⊢ div x✝² 0 = x✝² / 0
Theorem: Mathlib.Tactic.Ring.pow_add
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
b₁ : ℕ
c₁ : R
b₂ : ℕ
c₂ d : R
x✝² : a ^ b₁ = c₁
x✝¹ : a ^ b₂ = c₂
x✝ : c₁ * c₂ = d
⊢ a ^ (b₁ + b₂) = d

tactic: simp [_root_.pow_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
b₁ b₂ : ℕ
⊢ a ^ (b₁ + b₂) = a ^ b₁ * a ^ b₂
Theorem: Polynomial.isUnit_map
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp_rw [isUnit_iff_degree_eq_zero, degree_map]
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]
inst✝ : Field k
f : R →+* k
⊢ IsUnit (map f p) ↔ IsUnit p
Theorem: EuclideanDomain.lcm_zero_right
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [lcm, mul_zero, zero_div]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x : R
⊢ lcm x 0 = 0
Theorem: List.getLast?_eq_get?
File: Std/Data/List/Lemmas.lean

tactic: rw [getLast?_eq_getLast (a::l) fun., getLast_eq_get, get?_eq_get]
state_before: α : Type u_1
a : α
l : List α
⊢ getLast? (a :: l) = get? (a :: l) (length (a :: l) - 1)
Theorem: tangentCone_mono
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: rintro y ⟨c, d, ds, ctop, clim⟩
state_before: 𝕜 : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.19394
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.19484
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y : E
s t : Set E
h : s ⊆ t
⊢ tangentConeAt 𝕜 s x ⊆ tangentConeAt 𝕜 t x

tactic: exact ⟨c, d, mem_of_superset ds fun n hn => h hn, ctop, clim⟩
state_before: case intro.intro.intro.intro
𝕜 : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.19394
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.19484
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
x y✝ : E
s t : Set E
h : s ⊆ t
y : E
c : ℕ → 𝕜
d : ℕ → E
ds : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
ctop : Tendsto (fun n => ‖c n‖) atTop atTop
clim : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ tangentConeAt 𝕜 t x
Theorem: isCoatomic_of_isAtomic_of_complementedLattice_of_isModular
File: Mathlib/Order/Atoms.lean

tactic: rcases exists_isCompl x with ⟨y, xy⟩
state_before: α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x : α
⊢ x = ⊤ ∨ ∃ a, IsCoatom a ∧ x ≤ a

tactic: apply (eq_bot_or_exists_atom_le y).imp _ _
state_before: case intro
α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
⊢ x = ⊤ ∨ ∃ a, IsCoatom a ∧ x ≤ a

tactic: rintro rfl
state_before: α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
⊢ y = ⊥ → x = ⊤

tactic: exact eq_top_of_isCompl_bot xy
state_before: α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x : α
xy : IsCompl x ⊥
⊢ x = ⊤

tactic: rintro ⟨a, ha, ay⟩
state_before: α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
⊢ (∃ a, IsAtom a ∧ a ≤ y) → ∃ a, IsCoatom a ∧ x ≤ a

tactic: rcases exists_isCompl (xy.symm.IicOrderIsoIci ⟨a, ay⟩) with ⟨⟨b, xb⟩, hb⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
a : α
ha : IsAtom a
ay : a ≤ y
⊢ ∃ a, IsCoatom a ∧ x ≤ a

tactic: refine' ⟨↑(⟨b, xb⟩ : Set.Ici x), IsCoatom.of_isCoatom_coe_Ici _, xb⟩
state_before: case intro.intro.intro.mk
α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
a : α
ha : IsAtom a
ay : a ≤ y
b : α
xb : b ∈ Set.Ici x
hb : IsCompl (↑(IsCompl.IicOrderIsoIci (_ : IsCompl y x)) { val := a, property := ay }) { val := b, property := xb }
⊢ ∃ a, IsCoatom a ∧ x ≤ a

tactic: rw [← hb.isAtom_iff_isCoatom, OrderIso.isAtom_iff]
state_before: case intro.intro.intro.mk
α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
a : α
ha : IsAtom a
ay : a ≤ y
b : α
xb : b ∈ Set.Ici x
hb : IsCompl (↑(IsCompl.IicOrderIsoIci (_ : IsCompl y x)) { val := a, property := ay }) { val := b, property := xb }
⊢ IsCoatom { val := b, property := xb }

tactic: apply ha.Iic
state_before: case intro.intro.intro.mk
α : Type u_1
β : Type ?u.78195
inst✝⁴ : Lattice α
inst✝³ : BoundedOrder α
inst✝² : IsModularLattice α
inst✝¹ : ComplementedLattice α
inst✝ : IsAtomic α
x y : α
xy : IsCompl x y
a : α
ha : IsAtom a
ay : a ≤ y
b : α
xb : b ∈ Set.Ici x
hb : IsCompl (↑(IsCompl.IicOrderIsoIci (_ : IsCompl y x)) { val := a, property := ay }) { val := b, property := xb }
⊢ IsAtom { val := a, property := ay }
Theorem: String.Iterator.ValidFor.hasNext
File: Std/Data/String/Lemmas.lean

tactic: simp [Iterator.hasNext, ← h.atEnd, Iterator.atEnd]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ Iterator.hasNext it = true ↔ r ≠ []
Theorem: Dfinsupp.neLocus_self_sub_left
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: rw [neLocus_comm, neLocus_self_sub_right]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ neLocus (f - g) f = support g
Theorem: WithBot.bot_lt_iff_ne_bot
File: Mathlib/Order/WithBot.lean

tactic: simpa using not_lt_none ⊥
state_before: α : Type u_1
β : Type ?u.21635
γ : Type ?u.21638
δ : Type ?u.21641
a b : α
inst✝ : LT α
⊢ ⊥ < ⊥ ↔ ⊥ ≠ ⊥

tactic: simp [bot_lt_coe]
state_before: α : Type u_1
β : Type ?u.21635
γ : Type ?u.21638
δ : Type ?u.21641
a b : α
inst✝ : LT α
x : α
⊢ ⊥ < ↑x ↔ ↑x ≠ ⊥
Theorem: LieSubmodule.subsingleton_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← subsingleton_iff_bot_eq_top, ← subsingleton_iff_bot_eq_top, ← coe_toSubmodule_eq_iff,
  top_coeSubmodule, bot_coeSubmodule]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ Subsingleton (LieSubmodule R L M) ↔ Subsingleton (Submodule R M)
Theorem: Matrix.inv_inv_of_invertible
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp only [← invOf_eq_nonsing_inv, invOf_invOf]
state_before: l : Type ?u.198656
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
⊢ A⁻¹⁻¹ = A
Theorem: ContinuousLinearMap.norm_iteratedFDeriv_le_of_bilinear
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp_rw [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.4049704
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDeriv 𝕜 n (fun y => ↑(↑B (f y)) (g y)) x‖ ≤
    ‖B‖ * ∑ i in Finset.range (n + 1), ↑(Nat.choose n i) * ‖iteratedFDeriv 𝕜 i f x‖ * ‖iteratedFDeriv 𝕜 (n - i) g x‖

tactic: exact B.norm_iteratedFDerivWithin_le_of_bilinear hf.contDiffOn hg.contDiffOn uniqueDiffOn_univ
  (mem_univ x) hn
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.4049704
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
B : E →L[𝕜] F →L[𝕜] G
f : D → E
g : D → F
N : ℕ∞
hf : ContDiff 𝕜 N f
hg : ContDiff 𝕜 N g
x : D
n : ℕ
hn : ↑n ≤ N
⊢ ‖iteratedFDerivWithin 𝕜 n (fun y => ↑(↑B (f y)) (g y)) univ x‖ ≤
    ‖B‖ *
      ∑ x_1 in Finset.range (n + 1),
        ↑(Nat.choose n x_1) * ‖iteratedFDerivWithin 𝕜 x_1 f univ x‖ * ‖iteratedFDerivWithin 𝕜 (n - x_1) g univ x‖
Theorem: ReaderT.ext
File: src/lean/Init/Control/Lawful.lean

tactic: simp [run] at h
state_before: ρ : Type u_1
m : Type u_1 → Type u_2
α : Type u_1
x y : ReaderT ρ m α
h : ∀ (ctx : ρ), run x ctx = run y ctx
⊢ x = y

tactic: exact funext h
state_before: ρ : Type u_1
m : Type u_1 → Type u_2
α : Type u_1
x y : ReaderT ρ m α
h : ∀ (ctx : ρ), x ctx = y ctx
⊢ x = y
Theorem: Int.isUnit_iff_abs_eq
File: Mathlib/Data/Int/Order/Units.lean

tactic: rw [isUnit_iff_natAbs_eq, abs_eq_natAbs, ← Int.ofNat_one, coe_nat_inj']
state_before: x : ℤ
⊢ IsUnit x ↔ abs x = 1
Theorem: Stream'.Seq1.map_join
File: Mathlib/Data/Seq/Seq.lean

tactic: apply recOn s <;> intros <;> simp [map]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Seq α
S : Seq (Seq1 α)
⊢ map f (join ((a, s), S)) = join (map (map f) ((a, s), S))
Theorem: exists_seq_tendsto_sSup
File: Mathlib/Topology/Order/Basic.lean

tactic: rcases(isLUB_csSup hS hS').exists_seq_monotone_tendsto hS with ⟨u, hu⟩
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁹ : TopologicalSpace α✝
inst✝⁸ : TopologicalSpace β
inst✝⁷ : LinearOrder α✝
inst✝⁶ : LinearOrder β
inst✝⁵ : OrderTopology α✝
inst✝⁴ : OrderTopology β
α : Type u_1
inst✝³ : ConditionallyCompleteLinearOrder α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : FirstCountableTopology α
S : Set α
hS : Set.Nonempty S
hS' : BddAbove S
⊢ ∃ u, Monotone u ∧ Tendsto u atTop (𝓝 (sSup S)) ∧ ∀ (n : ℕ), u n ∈ S

tactic: exact ⟨u, hu.1, hu.2.2⟩
state_before: case intro
α✝ : Type u
β : Type v
γ : Type w
inst✝⁹ : TopologicalSpace α✝
inst✝⁸ : TopologicalSpace β
inst✝⁷ : LinearOrder α✝
inst✝⁶ : LinearOrder β
inst✝⁵ : OrderTopology α✝
inst✝⁴ : OrderTopology β
α : Type u_1
inst✝³ : ConditionallyCompleteLinearOrder α
inst✝² : TopologicalSpace α
inst✝¹ : OrderTopology α
inst✝ : FirstCountableTopology α
S : Set α
hS : Set.Nonempty S
hS' : BddAbove S
u : ℕ → α
hu : Monotone u ∧ (∀ (n : ℕ), u n ≤ sSup S) ∧ Tendsto u atTop (𝓝 (sSup S)) ∧ ∀ (n : ℕ), u n ∈ S
⊢ ∃ u, Monotone u ∧ Tendsto u atTop (𝓝 (sSup S)) ∧ ∀ (n : ℕ), u n ∈ S