tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.add_haar_ball_mul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rcases LE.le.eq_or_lt hr with (h | h)
state_before: E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.1982183
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s✝ : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
⊢ ↑↑μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (ball 0 s)

tactic: simp only [← h, zero_pow (finrank_pos (K := ℝ) (V := E)), measure_empty, zero_mul,
  ENNReal.ofReal_zero, ball_zero]
state_before: case inl
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.1982183
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s✝ : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
h : 0 = r
⊢ ↑↑μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (ball 0 s)

tactic: exact add_haar_ball_mul_of_pos μ x h s
state_before: case inr
E : Type u_1
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : MeasurableSpace E
inst✝⁶ : BorelSpace E
inst✝⁵ : FiniteDimensional ℝ E
μ : Measure E
inst✝⁴ : IsAddHaarMeasure μ
F : Type ?u.1982183
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
s✝ : Set E
inst✝ : Nontrivial E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
h : 0 < r
⊢ ↑↑μ (ball x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (ball 0 s)
Theorem: soln_dist_to_a_lt_deriv
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: rw [soln_dist_to_a, div_lt_iff]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ ‖soln - a‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: rwa [sq] at hnorm
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ ‖Polynomial.eval a F‖ <
    ‖Polynomial.eval a (↑Polynomial.derivative F)‖ * ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: apply deriv_norm_pos
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ 0 < ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: assumption
state_before: case hnorm
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2

tactic: exact hnsol
state_before: case hnsol
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ Polynomial.eval a F ≠ 0
Theorem: Nat.ModEq.mul_left_cancel'
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [modEq_iff_dvd, ← mul_sub, mul_dvd_mul_iff_left (by simp [hc] : (c : ℤ) ≠ 0)]
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ c * a ≡ c * b [MOD c * m] → a ≡ b [MOD m]

tactic: simp [hc]
state_before: m✝ n a✝ b✝ c✝ d a b c m : ℕ
hc : c ≠ 0
⊢ ↑c ≠ 0
Theorem: MeasureTheory.memℒp_top_of_bound
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [snorm_exponent_top]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.1834698
G : Type ?u.1834701
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ snorm f ⊤ μ < ⊤

tactic: exact snormEssSup_lt_top_of_ae_bound hfC
state_before: α : Type u_1
E : Type u_2
F : Type ?u.1834698
G : Type ?u.1834701
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ snormEssSup f μ < ⊤
Theorem: List.countp_mono_left
File: Mathlib/Data/List/Count.lean

tactic: induction' l with a l ihl
state_before: α : Type u_1
l : List α
p q : α → Bool
h : ∀ (x : α), x ∈ l → p x = true → q x = true
⊢ countp p l ≤ countp q l

tactic: rw [forall_mem_cons] at h
state_before: case cons
α : Type u_1
l✝ : List α
p q : α → Bool
h✝ : ∀ (x : α), x ∈ l✝ → p x = true → q x = true
a : α
l : List α
ihl : (∀ (x : α), x ∈ l → p x = true → q x = true) → countp p l ≤ countp q l
h : ∀ (x : α), x ∈ a :: l → p x = true → q x = true
⊢ countp p (a :: l) ≤ countp q (a :: l)

tactic: cases' h with ha hl
state_before: case cons
α : Type u_1
l✝ : List α
p q : α → Bool
h✝ : ∀ (x : α), x ∈ l✝ → p x = true → q x = true
a : α
l : List α
ihl : (∀ (x : α), x ∈ l → p x = true → q x = true) → countp p l ≤ countp q l
h : (p a = true → q a = true) ∧ ∀ (x : α), x ∈ l → p x = true → q x = true
⊢ countp p (a :: l) ≤ countp q (a :: l)

tactic: rw [countp_cons, countp_cons]
state_before: case cons.intro
α : Type u_1
l✝ : List α
p q : α → Bool
h : ∀ (x : α), x ∈ l✝ → p x = true → q x = true
a : α
l : List α
ihl : (∀ (x : α), x ∈ l → p x = true → q x = true) → countp p l ≤ countp q l
ha : p a = true → q a = true
hl : ∀ (x : α), x ∈ l → p x = true → q x = true
⊢ countp p (a :: l) ≤ countp q (a :: l)

tactic: refine' _root_.add_le_add (ihl hl) _
state_before: case cons.intro
α : Type u_1
l✝ : List α
p q : α → Bool
h : ∀ (x : α), x ∈ l✝ → p x = true → q x = true
a : α
l : List α
ihl : (∀ (x : α), x ∈ l → p x = true → q x = true) → countp p l ≤ countp q l
ha : p a = true → q a = true
hl : ∀ (x : α), x ∈ l → p x = true → q x = true
⊢ (countp p l + if p a = true then 1 else 0) ≤ countp q l + if q a = true then 1 else 0

tactic: split_ifs <;> simp only [le_rfl, _root_.zero_le]
state_before: case cons.intro
α : Type u_1
l✝ : List α
p q : α → Bool
h : ∀ (x : α), x ∈ l✝ → p x = true → q x = true
a : α
l : List α
ihl : (∀ (x : α), x ∈ l → p x = true → q x = true) → countp p l ≤ countp q l
ha : p a = true → q a = true
hl : ∀ (x : α), x ∈ l → p x = true → q x = true
⊢ (if p a = true then 1 else 0) ≤ if q a = true then 1 else 0

tactic: exact absurd (ha ‹_›) ‹_›
state_before: case cons.intro.inl.inr
α : Type u_1
l✝ : List α
p q : α → Bool
h : ∀ (x : α), x ∈ l✝ → p x = true → q x = true
a : α
l : List α
ihl : (∀ (x : α), x ∈ l → p x = true → q x = true) → countp p l ≤ countp q l
ha : p a = true → q a = true
hl : ∀ (x : α), x ∈ l → p x = true → q x = true
h✝¹ : p a = true
h✝ : ¬q a = true
⊢ False

tactic: rfl
state_before: case nil
α : Type u_1
l : List α
p q : α → Bool
h✝ : ∀ (x : α), x ∈ l → p x = true → q x = true
h : ∀ (x : α), x ∈ [] → p x = true → q x = true
⊢ countp p [] ≤ countp q []
Theorem: Stream'.nth_tails
File: Mathlib/Data/Stream/Init.lean

tactic: intro n
state_before: α : Type u
β : Type v
δ : Type w
⊢ ∀ (n : ℕ) (s : Stream' α), nth (tails s) n = drop n (tail s)

tactic: induction' n with n' ih
state_before: α : Type u
β : Type v
δ : Type w
n : ℕ
⊢ ∀ (s : Stream' α), nth (tails s) n = drop n (tail s)

tactic: intros
state_before: case zero
α : Type u
β : Type v
δ : Type w
⊢ ∀ (s : Stream' α), nth (tails s) zero = drop zero (tail s)

tactic: rfl
state_before: case zero
α : Type u
β : Type v
δ : Type w
s✝ : Stream' α
⊢ nth (tails s✝) zero = drop zero (tail s✝)

tactic: intro s
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), nth (tails s) n' = drop n' (tail s)
⊢ ∀ (s : Stream' α), nth (tails s) (succ n') = drop (succ n') (tail s)

tactic: rw [nth_succ, drop_succ, tails_eq, tail_cons, ih]
state_before: case succ
α : Type u
β : Type v
δ : Type w
n' : ℕ
ih : ∀ (s : Stream' α), nth (tails s) n' = drop n' (tail s)
s : Stream' α
⊢ nth (tails s) (succ n') = drop (succ n') (tail s)
Theorem: Polynomial.support_update
File: Mathlib/Data/Polynomial/Basic.lean

tactic: classical
  cases p
  simp only [support, update, Finsupp.support_update]
  congr
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
inst✝ : Decidable (a = 0)
⊢ support (update p n a) = if a = 0 then Finset.erase (support p) n else insert n (support p)

tactic: cases p
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
inst✝ : Decidable (a = 0)
⊢ support (update p n a) = if a = 0 then Finset.erase (support p) n else insert n (support p)

tactic: simp only [support, update, Finsupp.support_update]
state_before: case ofFinsupp
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q : R[X]
n : ℕ
a : R
inst✝ : Decidable (a = 0)
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ support (update { toFinsupp := toFinsupp✝ } n a) =
    if a = 0 then Finset.erase (support { toFinsupp := toFinsupp✝ }) n
    else insert n (support { toFinsupp := toFinsupp✝ })

tactic: congr
state_before: case ofFinsupp
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q : R[X]
n : ℕ
a : R
inst✝ : Decidable (a = 0)
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ (if a = 0 then Finset.erase toFinsupp✝.support n else insert n toFinsupp✝.support) =
    if a = 0 then Finset.erase toFinsupp✝.support n else insert n toFinsupp✝.support
Theorem: CategoryTheory.Limits.IsColimit.OfNatIso.cocone_fac
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: rw [← coconeOfHom_homOfCocone h s]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
⊢ Cocone.extend (colimitCocone h) (homOfCocone h s) = s

tactic: conv_lhs => simp only [homOfCocone_cooneOfHom]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
⊢ Cocone.extend (colimitCocone h) (homOfCocone h (coconeOfHom h (homOfCocone h s))) = coconeOfHom h (homOfCocone h s)

tactic: apply (coconeOfHom_fac _ _).symm
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj X.op ⋙ uliftFunctor ≅ Functor.cocones F
s : Cocone F
⊢ Cocone.extend (colimitCocone h) (homOfCocone h s) = coconeOfHom h (homOfCocone h s)
Theorem: Submonoid.mem_iSup
File: Mathlib/GroupTheory/Submonoid/Basic.lean

tactic: rw [← closure_singleton_le_iff_mem, le_iSup_iff]
state_before: M : Type u_2
N : Type ?u.29131
A : Type ?u.29134
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_1
p : ι → Submonoid M
m : M
⊢ (m ∈ ⨆ (i : ι), p i) ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N

tactic: simp only [closure_singleton_le_iff_mem]
state_before: M : Type u_2
N : Type ?u.29131
A : Type ?u.29134
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
ι : Sort u_1
p : ι → Submonoid M
m : M
⊢ (∀ (b : Submonoid M), (∀ (i : ι), p i ≤ b) → closure {m} ≤ b) ↔ ∀ (N : Submonoid M), (∀ (i : ι), p i ≤ N) → m ∈ N
Theorem: MeasureTheory.Memℒp.of_measure_le_smul
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: refine' ⟨hf.1.mono' (Measure.absolutelyContinuous_of_le_smul hμ'_le), _⟩
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
⊢ Memℒp f p

tactic: refine' (snorm_mono_measure f hμ'_le).trans_lt _
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
⊢ snorm f p μ' < ⊤

tactic: by_cases hc0 : c = 0
state_before: α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
⊢ snorm f p (c • μ) < ⊤

tactic: rw [snorm_smul_measure_of_ne_zero hc0, smul_eq_mul]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
hc0 : ¬c = 0
⊢ snorm f p (c • μ) < ⊤

tactic: refine' ENNReal.mul_lt_top _ hf.2.ne
state_before: case neg
α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
hc0 : ¬c = 0
⊢ c ^ ENNReal.toReal (1 / p) * snorm f p μ < ⊤

tactic: simp [hc, hc0]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
hc0 : ¬c = 0
⊢ c ^ ENNReal.toReal (1 / p) ≠ ⊤

tactic: simp [hc0]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type ?u.2303726
G : Type ?u.2303729
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → E
hf : Memℒp f p
hc0 : c = 0
⊢ snorm f p (c • μ) < ⊤
Theorem: Real.mem_closure_iff
File: Mathlib/Topology/Instances/Real.lean

tactic: simp [mem_closure_iff_nhds_basis nhds_basis_ball, Real.dist_eq]
state_before: α : Type u
β : Type v
γ : Type w
s : Set ℝ
x : ℝ
⊢ x ∈ closure s ↔ ∀ (ε : ℝ), ε > 0 → ∃ y, y ∈ s ∧ abs (y - x) < ε
Theorem: LipschitzWith.const_min
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [min_comm] using hf.min_const a
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
Kf Kg : ℝ≥0
hf : LipschitzWith Kf f
a : ℝ
⊢ LipschitzWith Kf fun x => min a (f x)
Theorem: LieSubalgebra.normalizer_eq_self_of_isCartanSubalgebra
File: Mathlib/Algebra/Lie/CartanSubalgebra.lean

tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, coe_normalizer_eq_normalizer,
  IsCartanSubalgebra.self_normalizing, coe_toLieSubmodule]
state_before: R : Type u
L : Type v
inst✝³ : CommRing R
inst✝² : LieRing L
inst✝¹ : LieAlgebra R L
H✝ H : LieSubalgebra R L
inst✝ : IsCartanSubalgebra H
⊢ LieSubmodule.normalizer (toLieSubmodule H) = toLieSubmodule H
Theorem: PNat.Coprime.gcd_mul
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [← coprime_coe] at h
state_before: k m n : ℕ+
h : Coprime m n
⊢ gcd k (m * n) = gcd k m * gcd k n

tactic: apply eq
state_before: k m n : ℕ+
h : coprime ↑m ↑n
⊢ gcd k (m * n) = gcd k m * gcd k n

tactic: simp only [gcd_coe, mul_coe]
state_before: case a
k m n : ℕ+
h : coprime ↑m ↑n
⊢ ↑(gcd k (m * n)) = ↑(gcd k m * gcd k n)

tactic: apply Nat.coprime.gcd_mul k h
state_before: case a
k m n : ℕ+
h : coprime ↑m ↑n
⊢ Nat.gcd (↑k) (↑m * ↑n) = Nat.gcd ↑k ↑m * Nat.gcd ↑k ↑n
Theorem: List.countp_le_length
File: Mathlib/Data/List/Count.lean

tactic: simpa only [countp_eq_length_filter] using length_filter_le _ _
state_before: α : Type u_1
l : List α
p q : α → Bool
⊢ countp p l ≤ length l
Theorem: CategoryTheory.CosimplicialObject.eqToIso_refl
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
h : n = n
⊢ eqToIso X h = Iso.refl (X.obj [n])

tactic: simp [eqToIso]
state_before: case w
C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
h : n = n
⊢ (eqToIso X h).hom = (Iso.refl (X.obj [n])).hom
Theorem: ProjectiveSpectrum.sup_vanishingIdeal_le
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: intro r
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 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
⊢ vanishingIdeal t ⊔ vanishingIdeal t' ≤ vanishingIdeal (t ∩ t')

tactic: rw [← HomogeneousIdeal.mem_iff, HomogeneousIdeal.toIdeal_sup, mem_vanishingIdeal,
  Submodule.mem_sup]
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 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
r : A
⊢ r ∈ vanishingIdeal t ⊔ vanishingIdeal t' → r ∈ vanishingIdeal (t ∩ t')

tactic: rintro ⟨f, hf, g, hg, rfl⟩ x ⟨hxt, hxt'⟩
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 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
r : A
⊢ (∃ y,
      y ∈ HomogeneousIdeal.toIdeal (vanishingIdeal t) ∧
        ∃ z, z ∈ HomogeneousIdeal.toIdeal (vanishingIdeal t') ∧ y + z = r) →
    ∀ (x : ProjectiveSpectrum 𝒜), x ∈ t ∩ t' → r ∈ x.asHomogeneousIdeal

tactic: erw [mem_vanishingIdeal] at hf hg
state_before: case intro.intro.intro.intro.intro
R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
f : A
hf : f ∈ HomogeneousIdeal.toIdeal (vanishingIdeal t)
g : A
hg : g ∈ HomogeneousIdeal.toIdeal (vanishingIdeal t')
x : ProjectiveSpectrum 𝒜
hxt : x ∈ t
hxt' : x ∈ t'
⊢ f + g ∈ x.asHomogeneousIdeal

tactic: apply Submodule.add_mem <;> solve_by_elim
state_before: case intro.intro.intro.intro.intro
R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
t t' : Set (ProjectiveSpectrum 𝒜)
f : A
hf : ∀ (x : ProjectiveSpectrum 𝒜), x ∈ t → f ∈ x.asHomogeneousIdeal
g : A
hg : ∀ (x : ProjectiveSpectrum 𝒜), x ∈ t' → g ∈ x.asHomogeneousIdeal
x : ProjectiveSpectrum 𝒜
hxt : x ∈ t
hxt' : x ∈ t'
⊢ f + g ∈ x.asHomogeneousIdeal
Theorem: List.Func.mem_get_of_ne_zero
File: Mathlib/Data/List/Func.lean

tactic: exfalso
state_before: α : Type u
β : Type v
γ : Type w
a : α
as as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x✝ : ℕ
h1 : get x✝ [] ≠ default
⊢ get x✝ [] ∈ []

tactic: apply h1
state_before: case h
α : Type u
β : Type v
γ : Type w
a : α
as as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x✝ : ℕ
h1 : get x✝ [] ≠ default
⊢ False

tactic: rw [get_nil]
state_before: case h
α : Type u
β : Type v
γ : Type w
a : α
as as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x✝ : ℕ
h1 : get x✝ [] ≠ default
⊢ get x✝ [] = default

tactic: rw [mem_cons]
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a : α
as : List α
x✝ : get 0 (a :: as) ≠ default
⊢ get 0 (a :: as) ∈ a :: as

tactic: exact Or.inl rfl
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a : α
as : List α
x✝ : get 0 (a :: as) ≠ default
⊢ get 0 (a :: as) = a ∨ get 0 (a :: as) ∈ as

tactic: rw [mem_cons]
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : get (n + 1) (a :: as) ≠ default
⊢ get (n + 1) (a :: as) ∈ a :: as

tactic: unfold get
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : get (n + 1) (a :: as) ≠ default
⊢ get (n + 1) (a :: as) = a ∨ get (n + 1) (a :: as) ∈ as

tactic: apply Or.inr (mem_get_of_ne_zero _)
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : get (n + 1) (a :: as) ≠ default
⊢ get (Nat.add n 0) as = a ∨ get (Nat.add n 0) as ∈ as

tactic: apply h1
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : get (n + 1) (a :: as) ≠ default
⊢ get (Nat.add n 0) as ≠ default
Theorem: MeasureTheory.lintegral_singleton
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [restrict_singleton, lintegral_smul_measure, lintegral_dirac, mul_comm]
state_before: α : Type u_1
β : Type ?u.1729685
γ : Type ?u.1729688
δ : Type ?u.1729691
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSingletonClass α
f : α → ℝ≥0∞
a : α
⊢ (∫⁻ (x : α) in {a}, f x ∂μ) = f a * ↑↑μ {a}
Theorem: Nat.choose_symm_half
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: apply choose_symm_of_eq_add
state_before: m : ℕ
⊢ choose (2 * m + 1) (m + 1) = choose (2 * m + 1) m

tactic: rw [add_comm m 1, add_assoc 1 m m, add_comm (2 * m) 1, two_mul m]
state_before: case h
m : ℕ
⊢ 2 * m + 1 = m + 1 + m
Theorem: CategoryTheory.GrothendieckTopology.sheafifyMap_id
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: dsimp [sheafifyMap, sheafify]
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
⊢ sheafifyMap J (𝟙 P) = 𝟙 (sheafify J P)

tactic: simp
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
⊢ plusMap J (plusMap J (𝟙 P)) = 𝟙 (plusObj J (plusObj J P))
Theorem: FreeGroup.map.comp
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rcases x with ⟨L⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f✝ : α → β
x✝ y : FreeGroup α
γ : Type w
f : α → β
g : β → γ
x : FreeGroup α
⊢ ↑(map g) (↑(map f) x) = ↑(map (g ∘ f)) x
Theorem: Nat.cast_pow_eq_one
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rw [← cast_pow, cast_eq_one]
state_before: R✝ : Type ?u.400
inst✝³ : AddMonoidWithOne R✝
inst✝² : CharZero R✝
R : Type u_1
inst✝¹ : Semiring R
inst✝ : CharZero R
q n : ℕ
hn : n ≠ 0
⊢ ↑q ^ n = 1 ↔ q = 1

tactic: exact pow_eq_one_iff hn
state_before: R✝ : Type ?u.400
inst✝³ : AddMonoidWithOne R✝
inst✝² : CharZero R✝
R : Type u_1
inst✝¹ : Semiring R
inst✝ : CharZero R
q n : ℕ
hn : n ≠ 0
⊢ q ^ n = 1 ↔ q = 1
Theorem: PrimeSpectrum.vanishingIdeal_anti_mono_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← ht.closure_subset_iff, ← ht.closure_eq]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s t : Set (PrimeSpectrum R)
ht : IsClosed t
h : vanishingIdeal t ≤ vanishingIdeal s
⊢ s ⊆ t

tactic: convert ← zeroLocus_anti_mono_ideal h <;> apply zeroLocus_vanishingIdeal_eq_closure
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
s t : Set (PrimeSpectrum R)
ht : IsClosed t
h : vanishingIdeal t ≤ vanishingIdeal s
⊢ closure s ⊆ closure t
Theorem: Set.biUnion_range_preimage_singleton
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [biUnion_preimage_singleton, preimage_range]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.226879
ι : Sort ?u.226882
ι' : Sort ?u.226885
ι₂ : Sort ?u.226888
κ : ι → Sort ?u.226893
κ₁ : ι → Sort ?u.226898
κ₂ : ι → Sort ?u.226903
κ' : ι' → Sort ?u.226908
f : α → β
⊢ (⋃ (y : β) (_ : y ∈ range f), f ⁻¹' {y}) = univ