tasksource/leandojo huggingface dataset:
Theorem: MonoidAlgebra.support_single_mul_eq_image
File: Mathlib/Algebra/MonoidAlgebra/Support.lean

tactic: refine' subset_antisymm (support_single_mul_subset f _ _) fun y hy => _
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
⊢ (single x r * f).support = image ((fun x x_1 => x * x_1) x) f.support

tactic: obtain ⟨y, yf, rfl⟩ : ∃ a : G, a ∈ f.support ∧ x * a = y := by
  simpa only [Finset.mem_image, exists_prop] using hy
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
hy : y ∈ image ((fun x x_1 => x * x_1) x) f.support
⊢ y ∈ (single x r * f).support

tactic: simp only [mul_apply, mem_support_iff.mp yf, hr, mem_support_iff, sum_single_index,
  Finsupp.sum_ite_eq', Ne.def, not_false_iff, if_true, zero_mul, ite_self, sum_zero, lx.eq_iff]
state_before: case intro.intro
k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
yf : y ∈ f.support
hy : x * y ∈ image ((fun x x_1 => x * x_1) x) f.support
⊢ x * y ∈ (single x r * f).support

tactic: simpa only [Finset.mem_image, exists_prop] using hy
state_before: k : Type u₁
G : Type u₂
inst✝² : Semiring k
inst✝¹ : DecidableEq G
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
hr : ∀ (y : k), r * y = 0 ↔ y = 0
x : G
lx : IsLeftRegular x
y : G
hy : y ∈ image ((fun x x_1 => x * x_1) x) f.support
⊢ ∃ a, a ∈ f.support ∧ x * a = y
Theorem: Associated.isUnit
File: Mathlib/Algebra/Associated.lean

tactic: simp [hv, hu.symm]
state_before: α : Type u_1
β : Type ?u.216897
γ : Type ?u.216900
δ : Type ?u.216903
inst✝ : Monoid α
a b : α
h : a ~ᵤ b
u : αˣ
hu : a * ↑u = b
x✝ : IsUnit a
v : αˣ
hv : ↑v = a
⊢ ↑(v * u) = b
Theorem: Set.image_add_const_Iic
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x + a) '' Iic b = Iic (b + a)
Theorem: intervalIntegral.integral_of_ge
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [integral_symm b, integral_of_le h]
state_before: ι : Type ?u.9934822
𝕜 : Type ?u.9934825
E : Type u_1
F : Type ?u.9934831
A : Type ?u.9934834
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
h : b ≤ a
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) = -∫ (x : ℝ) in Ioc b a, f x ∂μ
Theorem: Polynomial.multiset_prod_X_sub_C_nextCoeff
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: rw [nextCoeff_multiset_prod]
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommRing R
t : Multiset R
⊢ nextCoeff (prod (Multiset.map (fun x => X - ↑C x) t)) = -Multiset.sum t

tactic: simp only [nextCoeff_X_sub_C]
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommRing R
t : Multiset R
⊢ Multiset.sum (Multiset.map (fun i => nextCoeff (X - ↑C i)) t) = -Multiset.sum t

tactic: exact t.sum_hom (-AddMonoidHom.id R)
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommRing R
t : Multiset R
⊢ Multiset.sum (Multiset.map (fun x => -x) t) = -Multiset.sum t

tactic: intros
state_before: case h
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommRing R
t : Multiset R
⊢ ∀ (i : R), i ∈ t → Monic (X - ↑C i)

tactic: apply monic_X_sub_C
state_before: case h
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommRing R
t : Multiset R
i✝ : R
a✝ : i✝ ∈ t
⊢ Monic (X - ↑C i✝)
Theorem: FractionalIdeal.map_ne_zero
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: obtain ⟨x, x_ne_zero, hx⟩ := exists_ne_zero_mem_isInteger hI
state_before: R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1079360
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
K : Type u_2
K' : Type u_3
inst✝⁶ : Field K
inst✝⁵ : Field K'
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : Algebra R K'
inst✝¹ : IsFractionRing R K'
I J : FractionalIdeal R⁰ K
h : K →ₐ[R] K'
inst✝ : Nontrivial R
hI : I ≠ 0
⊢ map h I ≠ 0

tactic: contrapose! x_ne_zero with map_eq_zero
state_before: case intro.intro
R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1079360
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
K : Type u_2
K' : Type u_3
inst✝⁶ : Field K
inst✝⁵ : Field K'
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : Algebra R K'
inst✝¹ : IsFractionRing R K'
I J : FractionalIdeal R⁰ K
h : K →ₐ[R] K'
inst✝ : Nontrivial R
hI : I ≠ 0
x : R
x_ne_zero : x ≠ 0
hx : ↑(algebraMap R K) x ∈ I
⊢ map h I ≠ 0

tactic: refine' IsFractionRing.to_map_eq_zero_iff.mp (eq_zero_iff.mp map_eq_zero _ (mem_map.mpr _))
state_before: case intro.intro
R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1079360
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
K : Type u_2
K' : Type u_3
inst✝⁶ : Field K
inst✝⁵ : Field K'
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : Algebra R K'
inst✝¹ : IsFractionRing R K'
I J : FractionalIdeal R⁰ K
h : K →ₐ[R] K'
inst✝ : Nontrivial R
hI : I ≠ 0
x : R
hx : ↑(algebraMap R K) x ∈ I
map_eq_zero : map h I = 0
⊢ x = 0

tactic: exact ⟨algebraMap R K x, hx, h.commutes x⟩
state_before: case intro.intro
R : Type u_1
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1079360
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
K : Type u_2
K' : Type u_3
inst✝⁶ : Field K
inst✝⁵ : Field K'
inst✝⁴ : Algebra R K
inst✝³ : IsFractionRing R K
inst✝² : Algebra R K'
inst✝¹ : IsFractionRing R K'
I J : FractionalIdeal R⁰ K
h : K →ₐ[R] K'
inst✝ : Nontrivial R
hI : I ≠ 0
x : R
hx : ↑(algebraMap R K) x ∈ I
map_eq_zero : map h I = 0
⊢ ∃ x_1, x_1 ∈ I ∧ ↑h x_1 = ↑(algebraMap R K') x
Theorem: List.bind_eq_bindTR
File: Std/Data/List/Basic.lean

tactic: funext α β as f
state_before: ⊢ @List.bind = @bindTR

tactic: let rec go : ∀ as acc, bindTR.go f as acc = acc.data ++ as.bind f
  | [], acc => by simp [bindTR.go, bind]
  | x::xs, acc => by simp [bindTR.go, bind, go xs]
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
as : List α
f : α → List β
⊢ List.bind as f = bindTR as f

tactic: exact (go as #[]).symm
state_before: case h.h.h.h
α : Type u_2
β : Type u_1
as : List α
f : α → List β
⊢ List.bind as f = bindTR as f

tactic: simp [bindTR.go, bind]
state_before: α : Type u_2
β : Type u_1
as : List α
f : α → List β
acc : Array β
⊢ bindTR.go f [] acc = acc.data ++ List.bind [] f

tactic: simp [bindTR.go, bind, go xs]
state_before: α : Type u_2
β : Type u_1
as : List α
f : α → List β
x : α
xs : List α
acc : Array β
⊢ bindTR.go f (x :: xs) acc = acc.data ++ List.bind (x :: xs) f
Theorem: Complex.cosh_add_sinh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), mul_add, two_cosh, two_sinh, add_add_sub_cancel, two_mul]
state_before: x y : ℂ
⊢ cosh x + sinh x = exp x
Theorem: LinearMap.coe_pow
File: Mathlib/LinearAlgebra/Basic.lean

tactic: ext m
state_before: R : Type u_1
R₁ : Type ?u.166838
R₂ : Type ?u.166841
R₃ : Type ?u.166844
R₄ : Type ?u.166847
S : Type ?u.166850
K : Type ?u.166853
K₂ : Type ?u.166856
M : Type u_2
M' : Type ?u.166862
M₁ : Type ?u.166865
M₂ : Type ?u.166868
M₃ : Type ?u.166871
M₄ : Type ?u.166874
N : Type ?u.166877
N₂ : Type ?u.166880
ι : Type ?u.166883
V : Type ?u.166886
V₂ : Type ?u.166889
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f✝ : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f : M →ₗ[R] M
n : ℕ
⊢ ↑(f ^ n) = ↑f^[n]

tactic: apply pow_apply
state_before: case h
R : Type u_1
R₁ : Type ?u.166838
R₂ : Type ?u.166841
R₃ : Type ?u.166844
R₄ : Type ?u.166847
S : Type ?u.166850
K : Type ?u.166853
K₂ : Type ?u.166856
M : Type u_2
M' : Type ?u.166862
M₁ : Type ?u.166865
M₂ : Type ?u.166868
M₃ : Type ?u.166871
M₄ : Type ?u.166874
N : Type ?u.166877
N₂ : Type ?u.166880
ι : Type ?u.166883
V : Type ?u.166886
V₂ : Type ?u.166889
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
inst✝¹⁴ : Semiring R₄
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid M₁
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M₄
inst✝⁸ : Module R M
inst✝⁷ : Module R M₁
inst✝⁶ : Module R₂ M₂
inst✝⁵ : Module R₃ M₃
inst✝⁴ : Module R₄ M₄
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₃₄ : R₃ →+* R₄
σ₁₃ : R →+* R₃
σ₂₄ : R₂ →+* R₄
σ₁₄ : R →+* R₄
inst✝³ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝² : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
f✝ : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₃] M₃
f : M →ₗ[R] M
n : ℕ
m : M
⊢ ↑(f ^ n) m = (↑f^[n]) m
Theorem: RingSeminorm.ne_zero_iff
File: Mathlib/Analysis/Normed/Ring/Seminorm.lean

tactic: simp [eq_zero_iff]
state_before: F : Type ?u.10506
R : Type u_1
S : Type ?u.10512
x y : R
r : ℝ
inst✝ : NonUnitalRing R
p : RingSeminorm R
⊢ p ≠ 0 ↔ ∃ x, ↑p x ≠ 0
Theorem: Set.image_inter_mulSupport_eq
File: Mathlib/Algebra/Support.lean

tactic: rw [mulSupport_comp_eq_preimage f g, image_inter_preimage]
state_before: α : Type u_2
β : Type u_1
M : Type u_3
inst✝ : One M
f : α → M
s : Set β
g : β → α
⊢ g '' s ∩ mulSupport f = g '' (s ∩ mulSupport (f ∘ g))
Theorem: Submonoid.LocalizationMap.mul_mk'_one_eq_mk'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [mul_mk'_eq_mk'_of_mul, mul_one]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.936102
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ ↑(toMap f) x * mk' f 1 y = mk' f x y
Theorem: SimpleGraph.incMatrix_mul_transpose
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: ext (a b)
state_before: R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝⁴ : Fintype (Sym2 α)
inst✝³ : Semiring R
a b : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
⊢ incMatrix R G ⬝ (incMatrix R G)ᵀ = fun a b => if a = b then ↑(degree G a) else if Adj G a b then 1 else 0

tactic: split_ifs with h h'
state_before: case a.h
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝⁴ : Fintype (Sym2 α)
inst✝³ : Semiring R
a✝ b✝ : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a b : α
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a b = if a = b then ↑(degree G a) else if Adj G a b then 1 else 0

tactic: subst b
state_before: case a.h.inl
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝⁴ : Fintype (Sym2 α)
inst✝³ : Semiring R
a✝ b✝ : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a b : α
h : a = b
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a b = ↑(degree G a)

tactic: rename Semiring R => sr
state_before: case a.h.inl
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝⁴ : Fintype (Sym2 α)
inst✝³ : Semiring R
a✝ b : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a : α
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a a = ↑(degree G a)

tactic: convert @incMatrix_mul_transpose_diag _ _ _ _ sr.toNonAssocSemiring _ _ _
state_before: case a.h.inl
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝³ : Fintype (Sym2 α)
sr : Semiring R
a✝ b : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a : α
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a a = ↑(degree G a)

tactic: exact G.incMatrix_mul_transpose_apply_of_adj h'
state_before: case a.h.inr.inl
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝⁴ : Fintype (Sym2 α)
inst✝³ : Semiring R
a✝ b✝ : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a b : α
h : ¬a = b
h' : Adj G a b
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a b = 1

tactic: simp only [Matrix.mul_apply, Matrix.transpose_apply,
  G.incMatrix_apply_mul_incMatrix_apply_of_not_adj h h', sum_const_zero]
state_before: case a.h.inr.inr
R : Type u_2
α : Type u_1
G : SimpleGraph α
inst✝⁴ : Fintype (Sym2 α)
inst✝³ : Semiring R
a✝ b✝ : α
e : Sym2 α
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a b : α
h : ¬a = b
h' : ¬Adj G a b
⊢ (incMatrix R G ⬝ (incMatrix R G)ᵀ) a b = 0
Theorem: MeasureTheory.OuterMeasure.map_biInf_comap
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: haveI := hI.to_subtype
state_before: α : Type u_3
ι : Type u_1
β : Type u_2
I : Set ι
hI : Set.Nonempty I
f : α → β
m : ι → OuterMeasure β
⊢ ↑(map f) (⨅ (i : ι) (_ : i ∈ I), ↑(comap f) (m i)) = ⨅ (i : ι) (_ : i ∈ I), ↑(map f) (↑(comap f) (m i))

tactic: rw [← iInf_subtype'', ← iInf_subtype'']
state_before: α : Type u_3
ι : Type u_1
β : Type u_2
I : Set ι
hI : Set.Nonempty I
f : α → β
m : ι → OuterMeasure β
this : Nonempty ↑I
⊢ ↑(map f) (⨅ (i : ι) (_ : i ∈ I), ↑(comap f) (m i)) = ⨅ (i : ι) (_ : i ∈ I), ↑(map f) (↑(comap f) (m i))

tactic: exact map_iInf_comap _
state_before: α : Type u_3
ι : Type u_1
β : Type u_2
I : Set ι
hI : Set.Nonempty I
f : α → β
m : ι → OuterMeasure β
this : Nonempty ↑I
⊢ ↑(map f) (⨅ (i : ↑I), ↑(comap f) (m ↑i)) = ⨅ (i : ↑I), ↑(map f) (↑(comap f) (m ↑i))
Theorem: Std.RBNode.Ordered.lowerBound?_least
File: Std/Data/RBMap/Lemmas.lean

tactic: exact fun.
state_before: α : Type u_1
cmp : α → α → Ordering
cut : α → Ordering
t : RBNode α
x y : α
inst✝¹ : TransCmp cmp
inst✝ : IsCut cmp cut
ht : Ordered cmp t
H : x ∈ lowerBound? cut t none
hy : y ∈ t
xy : cmp x y = Ordering.lt
hx : cut x = Ordering.gt
⊢ ∀ {x : α}, x ∈ none → All (fun x_1 => cmpLT cmp x x_1) t
Theorem: le_himp_iff_left
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [le_himp_iff, inf_idem]
state_before: ι : Type ?u.27288
α : Type u_1
β : Type ?u.27294
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ a ≤ a ⇨ b ↔ a ≤ b
Theorem: LinearMap.IsProj.trace
File: Mathlib/LinearAlgebra/Trace.lean

tactic: rw [h.eq_conj_prodMap, trace_conj', trace_prodMap', trace_id, map_zero, add_zero]
state_before: R : Type u_1
inst✝¹³ : CommRing R
M : Type u_2
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
N : Type ?u.770483
inst✝¹⁰ : AddCommGroup N
inst✝⁹ : Module R N
ι : Type ?u.771025
inst✝⁸ : Module.Free R M
inst✝⁷ : Module.Finite R M
inst✝⁶ : Module.Free R N
inst✝⁵ : Module.Finite R N
inst✝⁴ : Nontrivial R
p : Submodule R M
f : M →ₗ[R] M
h : IsProj p f
inst✝³ : Module.Free R { x // x ∈ p }
inst✝² : Module.Finite R { x // x ∈ p }
inst✝¹ : Module.Free R { x // x ∈ ker f }
inst✝ : Module.Finite R { x // x ∈ ker f }
⊢ ↑(LinearMap.trace R M) f = ↑(finrank R { x // x ∈ p })
Theorem: MvPolynomial.totalDegree_eq
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: rw [totalDegree]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.326493
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ totalDegree p = Finset.sup (support p) fun m => ↑Multiset.card (↑toMultiset m)

tactic: congr
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.326493
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ (Finset.sup (support p) fun s => sum s fun x e => e) = Finset.sup (support p) fun m => ↑Multiset.card (↑toMultiset m)

tactic: funext m
state_before: case e_f
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.326493
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ (fun s => sum s fun x e => e) = fun m => ↑Multiset.card (↑toMultiset m)

tactic: exact (Finsupp.card_toMultiset _).symm
state_before: case e_f.h
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.326493
r : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
m : σ →₀ ℕ
⊢ (sum m fun x e => e) = ↑Multiset.card (↑toMultiset m)
Theorem: Finset.disjoint_filter
File: Mathlib/Data/Finset/Basic.lean

tactic: constructor <;> simp (config := { contextual := true }) [disjoint_left]
state_before: α : Type u_1
β : Type ?u.333912
γ : Type ?u.333915
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
⊢ _root_.Disjoint (filter p s) (filter q s) ↔ ∀ (x : α), x ∈ s → p x → ¬q x
Theorem: PGame.zero_lf_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lf_neg_iff, neg_zero]
state_before: x : PGame
⊢ 0 ⧏ -x ↔ x ⧏ 0
Theorem: Nat.Linear.Poly.denote_cons
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match p with
| []     => simp
| _ :: m => simp [denote_cons]
state_before: ctx : Context
k : Nat
v : Var
p : Poly
⊢ denote ctx ((k, v) :: p) = k * Var.denote ctx v + denote ctx p

tactic: simp
state_before: ctx : Context
k : Nat
v : Var
p : Poly
⊢ denote ctx [(k, v)] = k * Var.denote ctx v + denote ctx []

tactic: simp [denote_cons]
state_before: ctx : Context
k : Nat
v : Var
p : Poly
head✝ : Nat × Var
m : List (Nat × Var)
⊢ denote ctx ((k, v) :: head✝ :: m) = k * Var.denote ctx v + denote ctx (head✝ :: m)
Theorem: AlgebraicGeometry.PresheafedSpace.restrict_top_presheaf
File: Mathlib/AlgebraicGeometry/PresheafedSpace.lean

tactic: dsimp
state_before: C : Type u_1
inst✝ : Category C
X : PresheafedSpace C
⊢ (restrict X (_ : OpenEmbedding ((CategoryTheory.forget TopCat).map (Opens.inclusion ⊤)))).presheaf =
    (Opens.inclusionTopIso ↑X).inv _* X.presheaf

tactic: rw [Opens.inclusion_top_functor X.carrier]
state_before: C : Type u_1
inst✝ : Category C
X : PresheafedSpace C
⊢ Functor.op (IsOpenMap.functor (_ : IsOpenMap ((CategoryTheory.forget TopCat).map (Opens.inclusion ⊤)))) ⋙ X.presheaf =
    (Opens.inclusionTopIso ↑X).inv _* X.presheaf

tactic: rfl
state_before: C : Type u_1
inst✝ : Category C
X : PresheafedSpace C
⊢ Functor.op (Opens.map (Opens.inclusionTopIso ↑X).inv) ⋙ X.presheaf = (Opens.inclusionTopIso ↑X).inv _* X.presheaf
Theorem: TopCat.Presheaf.isGluing_iff_eq_res
File: Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean

tactic: constructor <;> intro h
state_before: C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
⊢ IsGluing F U ((piOpensIsoSectionsFamily F U).hom sf) s ↔ res F U s = sf

tactic: refine Types.limit_ext' _ _ _ fun ⟨i⟩ => ?_
state_before: case mp
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : IsGluing F U ((piOpensIsoSectionsFamily F U).hom sf) s
⊢ res F U s = sf

tactic: rw [res, Types.Limit.lift_π_apply', Fan.mk_π_app]
state_before: case mp
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : IsGluing F U ((piOpensIsoSectionsFamily F U).hom sf) s
x✝ : Discrete ι
i : ι
⊢ limit.π (Discrete.functor fun i => F.obj (U i).op) { as := i } (res F U s) =
    limit.π (Discrete.functor fun i => F.obj (U i).op) { as := i } sf

tactic: exact h i
state_before: case mp
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : IsGluing F U ((piOpensIsoSectionsFamily F U).hom sf) s
x✝ : Discrete ι
i : ι
⊢ F.map (leSupr U { as := i }.as).op s = limit.π (Discrete.functor fun i => F.obj (U i).op) { as := i } sf

tactic: intro i
state_before: case mpr
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : res F U s = sf
⊢ IsGluing F U ((piOpensIsoSectionsFamily F U).hom sf) s

tactic: convert congr_arg (Limits.Pi.π (fun i : ι => F.obj (op (U i))) i) h
state_before: case mpr
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : res F U s = sf
i : ι
⊢ (forget (Type v)).map (F.map (leSupr U i).op) s = (piOpensIsoSectionsFamily F U).hom sf i

tactic: rw [res, Types.pi_lift_π_apply]
state_before: case h.e'_2.h
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : res F U s = sf
i : ι
e_1✝ : (forget (Type v)).obj (F.obj (U i).op) = F.obj (U i).op
⊢ (forget (Type v)).map (F.map (leSupr U i).op) s = Pi.π (fun i => F.obj (U i).op) i (res F U s)

tactic: rfl
state_before: case h.e'_2.h
C : Type u
inst✝¹ : Category C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type v) X
ι : Type v
U : ι → Opens ↑X
sf : piOpens F U
s : F.obj (iSup U).op
h : res F U s = sf
i : ι
e_1✝ : (forget (Type v)).obj (F.obj (U i).op) = F.obj (U i).op
⊢ (forget (Type v)).map (F.map (leSupr U i).op) s = F.map (leSupr U i).op s
Theorem: Filter.frequently_and_distrib_left
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Filter.Frequently, not_and, eventually_imp_distrib_left, not_imp]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.169389
ι : Sort x
f : Filter α
p : Prop
q : α → Prop
⊢ (∃ᶠ (x : α) in f, p ∧ q x) ↔ p ∧ ∃ᶠ (x : α) in f, q x
Theorem: inner_sub_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp [sub_eq_add_neg, inner_add_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1769393
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y z : E
⊢ inner (x - y) z = inner x z - inner y z
Theorem: MeasureTheory.Measure.regular_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: rw [haarMeasure_unique μ ⟨⟨K, hK⟩, h2K⟩]
state_before: G : Type u_1
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : T2Space G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
inst✝² : SecondCountableTopology G
μ : Measure G
inst✝¹ : SigmaFinite μ
inst✝ : IsMulLeftInvariant μ
K : Set G
hK : IsCompact K
h2K : Set.Nonempty (interior K)
hμK : ↑↑μ K ≠ ⊤
⊢ Regular μ

tactic: exact Regular.smul hμK
state_before: G : Type u_1
inst✝⁸ : Group G
inst✝⁷ : TopologicalSpace G
inst✝⁶ : T2Space G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
inst✝² : SecondCountableTopology G
μ : Measure G
inst✝¹ : SigmaFinite μ
inst✝ : IsMulLeftInvariant μ
K : Set G
hK : IsCompact K
h2K : Set.Nonempty (interior K)
hμK : ↑↑μ K ≠ ⊤
⊢ Regular
    (↑↑μ ↑{ toCompacts := { carrier := K, isCompact' := hK }, interior_nonempty' := h2K } •
      haarMeasure { toCompacts := { carrier := K, isCompact' := hK }, interior_nonempty' := h2K })