tasksource/leandojo huggingface dataset:
Theorem: Polynomial.toSubring_one
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: rw [coeff_toSubring', coeff_one, coeff_one, apply_ite Subtype.val, ZeroMemClass.coe_zero,
  OneMemClass.coe_one]
state_before: R : Type u
S : Type ?u.98028
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
i : ℕ
⊢ ↑(coeff (toSubring 1 T (_ : ↑(frange 1) ⊆ ↑T)) i) = ↑(coeff 1 i)
Theorem: Basis.prod_apply_inl_fst
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext j
state_before: ι : Type u_3
ι' : Type u_4
R : Type u_5
R₂ : Type ?u.568294
K : Type ?u.568297
M : Type u_1
M' : Type u_2
M'' : Type ?u.568306
V : Type u
V' : Type ?u.568311
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i : ι
⊢ ↑b.repr (↑(Basis.prod b b') (Sum.inl i)).fst = ↑b.repr (↑b i)

tactic: simp only [Basis.prod, Basis.coe_ofRepr, LinearEquiv.symm_trans_apply, LinearEquiv.prod_symm,
  LinearEquiv.prod_apply, b.repr.apply_symm_apply, LinearEquiv.symm_symm, repr_self,
  Equiv.toFun_as_coe, Finsupp.fst_sumFinsuppLEquivProdFinsupp]
state_before: case h
ι : Type u_3
ι' : Type u_4
R : Type u_5
R₂ : Type ?u.568294
K : Type ?u.568297
M : Type u_1
M' : Type u_2
M'' : Type ?u.568306
V : Type u
V' : Type ?u.568311
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i j : ι
⊢ ↑(↑b.repr (↑(Basis.prod b b') (Sum.inl i)).fst) j = ↑(↑b.repr (↑b i)) j

tactic: apply Finsupp.single_apply_left Sum.inl_injective
state_before: case h
ι : Type u_3
ι' : Type u_4
R : Type u_5
R₂ : Type ?u.568294
K : Type ?u.568297
M : Type u_1
M' : Type u_2
M'' : Type ?u.568306
V : Type u
V' : Type ?u.568311
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
i j : ι
⊢ ↑(Finsupp.single (Sum.inl i) 1) (Sum.inl j) = ↑(Finsupp.single i 1) j
Theorem: Set.card_ne_eq
File: Mathlib/Data/Set/Finite.lean

tactic: haveI := Classical.decEq α
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1

tactic: rw [← toFinset_card, toFinset_setOf, Finset.filter_ne',
  Finset.card_erase_of_mem (Finset.mem_univ _), Finset.card_univ]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝¹ : Fintype α
a : α
inst✝ : Fintype ↑{x | x ≠ a}
this : DecidableEq α
⊢ Fintype.card ↑{x | x ≠ a} = Fintype.card α - 1
Theorem: AlternatingMap.compLinearMap_zero
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: ext
state_before: R : Type u_2
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_4
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.365369
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.365399
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.365787
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.366178
ι'' : Type ?u.366181
M₂ : Type u_5
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.366214
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : AlternatingMap R M N ι
⊢ compLinearMap f 0 = 0

tactic: simp_rw [compLinearMap_apply, LinearMap.zero_apply, ← Pi.zero_def, zero_apply]
state_before: case H
R : Type u_2
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_4
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.365369
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.365399
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.365787
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.366178
ι'' : Type ?u.366181
M₂ : Type u_5
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.366214
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : AlternatingMap R M N ι
x✝ : ι → M₂
⊢ ↑(compLinearMap f 0) x✝ = ↑0 x✝

tactic: exact map_zero f
state_before: case H
R : Type u_2
inst✝¹⁵ : Semiring R
M : Type u_3
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_4
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type ?u.365369
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type ?u.365399
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type ?u.365787
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_1
ι' : Type ?u.366178
ι'' : Type ?u.366181
M₂ : Type u_5
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type ?u.366214
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : AlternatingMap R M N ι
x✝ : ι → M₂
⊢ ↑f 0 = 0
Theorem: singleton_div_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [singleton_div_closedBall, div_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / closedBall 1 δ = closedBall x δ
Theorem: CategoryTheory.IsSubterminal.isIso_diag
File: Mathlib/CategoryTheory/Subterminal.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
A : C
hA : IsSubterminal A
inst✝ : HasBinaryProduct A A
⊢ diag A ≫ prod.fst = 𝟙 A

tactic: rw [IsSubterminal.def] at hA
state_before: C : Type u₁
inst✝¹ : Category C
A : C
hA : IsSubterminal A
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category C
A : C
hA : ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)
Theorem: AddCommGroup.self_modEq_zero
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ 0 - p = -1 • p
Theorem: Finset.piecewise_eq_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [piecewise, hi]
state_before: α : Type u_1
β : Type ?u.296498
γ : Type ?u.296501
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
i : α
hi : ¬i ∈ s
⊢ piecewise s f g i = g i
Theorem: Nat.multinomial_insert_one
File: Mathlib/Data/Nat/Choose/Multinomial.lean

tactic: simp only [multinomial, one_mul, factorial]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : ¬a ∈ s
h₁ : f a = 1
⊢ multinomial (insert a s) f = succ (Finset.sum s f) * multinomial s f

tactic: rw [Finset.sum_insert h, Finset.prod_insert h, h₁, add_comm, ← succ_eq_add_one, factorial_succ]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : ¬a ∈ s
h₁ : f a = 1
⊢ (∑ i in insert a s, f i)! / ∏ i in insert a s, (f i)! = succ (Finset.sum s f) * ((∑ i in s, f i)! / ∏ i in s, (f i)!)

tactic: simp only [factorial_one, one_mul, Function.comp_apply, factorial, mul_one, ← one_eq_succ_zero]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : ¬a ∈ s
h₁ : f a = 1
⊢ (∑ x in s, f x + 1) * (∑ x in s, f x)! / (1! * ∏ x in s, (f x)!) =
    succ (Finset.sum s f) * ((∑ i in s, f i)! / ∏ i in s, (f i)!)

tactic: rw [Nat.mul_div_assoc _ (prod_factorial_dvd_factorial_sum _ _)]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a b : α
n : ℕ
inst✝ : DecidableEq α
h : ¬a ∈ s
h₁ : f a = 1
⊢ (∑ x in s, f x + 1) * (∑ x in s, f x)! / ∏ x in s, (f x)! =
    succ (Finset.sum s f) * ((∑ x in s, f x)! / ∏ x in s, (f x)!)
Theorem: Pell.d_pos
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: decide
state_before: a : ℕ
a1 : 1 < a
⊢ 0 < 1
Theorem: multiplicity_normalizedFactorsEquivSpanNormalizedFactors_symm_eq_multiplicity
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: obtain ⟨x, hx⟩ := (normalizedFactorsEquivSpanNormalizedFactors hr).surjective I
state_before: R : Type u_1
A : Type ?u.1422103
K : Type ?u.1422106
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
inst✝⁴ : DecidableEq R
inst✝³ : DecidableEq (Ideal R)
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
r : R
hr : r ≠ 0
I : ↑{I | I ∈ normalizedFactors (span {r})}
⊢ multiplicity (↑(↑(normalizedFactorsEquivSpanNormalizedFactors hr).symm I)) r = multiplicity (↑I) (span {r})

tactic: obtain ⟨a, ha⟩ := x
state_before: case intro
R : Type u_1
A : Type ?u.1422103
K : Type ?u.1422106
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
inst✝⁴ : DecidableEq R
inst✝³ : DecidableEq (Ideal R)
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
r : R
hr : r ≠ 0
I : ↑{I | I ∈ normalizedFactors (span {r})}
x : ↑{d | d ∈ normalizedFactors r}
hx : ↑(normalizedFactorsEquivSpanNormalizedFactors hr) x = I
⊢ multiplicity (↑(↑(normalizedFactorsEquivSpanNormalizedFactors hr).symm I)) r = multiplicity (↑I) (span {r})

tactic: rw [hx.symm, Equiv.symm_apply_apply, Subtype.coe_mk,
  multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity hr ha, hx]
state_before: case intro.mk
R : Type u_1
A : Type ?u.1422103
K : Type ?u.1422106
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
inst✝⁴ : DecidableEq R
inst✝³ : DecidableEq (Ideal R)
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
r : R
hr : r ≠ 0
I : ↑{I | I ∈ normalizedFactors (span {r})}
a : R
ha : a ∈ {d | d ∈ normalizedFactors r}
hx : ↑(normalizedFactorsEquivSpanNormalizedFactors hr) { val := a, property := ha } = I
⊢ multiplicity (↑(↑(normalizedFactorsEquivSpanNormalizedFactors hr).symm I)) r = multiplicity (↑I) (span {r})
Theorem: Valuation.map_one_add_of_lt
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [← v.map_one] at h
state_before: K : Type ?u.2382416
F : Type ?u.2382419
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.2382431
Γ''₀ : Type ?u.2382434
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : ↑v x < 1
⊢ ↑v (1 + x) = 1

tactic: simpa only [v.map_one] using v.map_add_eq_of_lt_left h
state_before: K : Type ?u.2382416
F : Type ?u.2382419
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.2382431
Γ''₀ : Type ?u.2382434
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : ↑v x < ↑v 1
⊢ ↑v (1 + x) = 1
Theorem: finprod_induction
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod]
state_before: G : Type ?u.40810
M : Type u_1
N : Type ?u.40816
α : Sort u_2
β : Sort ?u.40822
ι : Sort ?u.40825
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
⊢ p (∏ᶠ (i : α), f i)

tactic: split_ifs
state_before: G : Type ?u.40810
M : Type u_1
N : Type ?u.40816
α : Sort u_2
β : Sort ?u.40822
ι : Sort ?u.40825
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
⊢ p (if h : Set.Finite (mulSupport ((fun i => f i) ∘ PLift.down)) then ∏ i in Finite.toFinset h, f i.down else 1)

tactic: exacts [Finset.prod_induction _ _ hp₁ hp₀ fun i _ => hp₂ _, hp₀]
state_before: case inl
G : Type ?u.40810
M : Type u_1
N : Type ?u.40816
α : Sort u_2
β : Sort ?u.40822
ι : Sort ?u.40825
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
h✝ : Set.Finite (mulSupport ((fun i => f i) ∘ PLift.down))
⊢ p (∏ i in Finite.toFinset h✝, f i.down)

case inr
G : Type ?u.40810
M : Type u_1
N : Type ?u.40816
α : Sort u_2
β : Sort ?u.40822
ι : Sort ?u.40825
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
h✝ : ¬Set.Finite (mulSupport ((fun i => f i) ∘ PLift.down))
⊢ p 1
Theorem: Homeomorph.self_trans_symm
File: Mathlib/Topology/Homeomorph.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.35926
δ : Type ?u.35929
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
⊢ Homeomorph.trans h (Homeomorph.symm h) = Homeomorph.refl α

tactic: apply symm_apply_apply
state_before: case H
α : Type u_1
β : Type u_2
γ : Type ?u.35926
δ : Type ?u.35929
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
x✝ : α
⊢ ↑(Homeomorph.trans h (Homeomorph.symm h)) x✝ = ↑(Homeomorph.refl α) x✝
Theorem: and_congr_left_iff
File: Std/Logic.lean

tactic: simp only [and_comm, ← and_congr_right_iff]
state_before: a c b : Prop
⊢ (a ∧ c ↔ b ∧ c) ↔ c → (a ↔ b)
Theorem: PNat.count_factorMultiset
File: Mathlib/Data/PNat/Factors.lean

tactic: intros
state_before: m : ℕ+
p : Nat.Primes
k : ℕ
⊢ Pow.pow (↑p) k ∣ m ↔ k ≤ Multiset.count p (factorMultiset m)

tactic: rw [Multiset.le_count_iff_replicate_le, ← factorMultiset_le_iff, factorMultiset_pow,
  factorMultiset_ofPrime]
state_before: m : ℕ+
p : Nat.Primes
k : ℕ
⊢ Pow.pow (↑p) k ∣ m ↔ k ≤ Multiset.count p (factorMultiset m)

tactic: congr! 2
state_before: m : ℕ+
p : Nat.Primes
k : ℕ
⊢ k • PrimeMultiset.ofPrime p ≤ factorMultiset m ↔ Multiset.replicate k p ≤ factorMultiset m

tactic: apply Multiset.eq_replicate.mpr
state_before: case a.h.e'_3.h
m : ℕ+
p : Nat.Primes
k : ℕ
e_1✝ : PrimeMultiset = Multiset Nat.Primes
⊢ k • PrimeMultiset.ofPrime p = Multiset.replicate k p

tactic: constructor
state_before: case a.h.e'_3.h
m : ℕ+
p : Nat.Primes
k : ℕ
e_1✝ : PrimeMultiset = Multiset Nat.Primes
⊢ ↑Multiset.card (k • PrimeMultiset.ofPrime p) = k ∧ ∀ (b : Nat.Primes), b ∈ k • PrimeMultiset.ofPrime p → b = p

tactic: rw [Multiset.card_nsmul, PrimeMultiset.card_ofPrime, mul_one]
state_before: case a.h.e'_3.h.left
m : ℕ+
p : Nat.Primes
k : ℕ
e_1✝ : PrimeMultiset = Multiset Nat.Primes
⊢ ↑Multiset.card (k • PrimeMultiset.ofPrime p) = k

tactic: intro q h
state_before: case a.h.e'_3.h.right
m : ℕ+
p : Nat.Primes
k : ℕ
e_1✝ : PrimeMultiset = Multiset Nat.Primes
⊢ ∀ (b : Nat.Primes), b ∈ k • PrimeMultiset.ofPrime p → b = p

tactic: rw [PrimeMultiset.ofPrime, Multiset.nsmul_singleton _ k] at h
state_before: case a.h.e'_3.h.right
m : ℕ+
p : Nat.Primes
k : ℕ
e_1✝ : PrimeMultiset = Multiset Nat.Primes
q : Nat.Primes
h : q ∈ k • PrimeMultiset.ofPrime p
⊢ q = p

tactic: exact Multiset.eq_of_mem_replicate h
state_before: case a.h.e'_3.h.right
m : ℕ+
p : Nat.Primes
k : ℕ
e_1✝ : PrimeMultiset = Multiset Nat.Primes
q : Nat.Primes
h : q ∈ Multiset.replicate k p
⊢ q = p
Theorem: LowerSet.map_map
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
ι : Sort ?u.107147
κ : ι → Sort ?u.107152
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
⊢ ↑(map g) (↑(map f) s) = ↑(map (OrderIso.trans f g)) s

tactic: simp
state_before: case a.h
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Sort ?u.107147
κ : ι → Sort ?u.107152
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
x✝ : γ
⊢ x✝ ∈ ↑(↑(map g) (↑(map f) s)) ↔ x✝ ∈ ↑(↑(map (OrderIso.trans f g)) s)
Theorem: Finset.weightedVSubOfPoint_apply
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [weightedVSubOfPoint, LinearMap.sum_apply]
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.8363
s₂ : Finset ι₂
w : ι → k
p : ι → P
b : P
⊢ ↑(weightedVSubOfPoint s p b) w = ∑ i in s, w i • (p i -ᵥ b)
Theorem: nhds_basis_zero_abs_sub_lt
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa using nhds_basis_abs_sub_lt (0 : α)
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrderedAddCommGroup α
inst✝¹ : OrderTopology α
l : Filter β
f g : β → α
inst✝ : NoMaxOrder α
⊢ HasBasis (𝓝 0) (fun ε => 0 < ε) fun ε => {b | abs b < ε}
Theorem: continuousAt_sign_of_pos
File: Mathlib/Topology/Instances/Sign.lean

tactic: refine' (continuousAt_const : ContinuousAt (fun _ => (1 : SignType)) a).congr _
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ ContinuousAt (↑SignType.sign) a

tactic: rw [Filter.EventuallyEq, eventually_nhds_iff]
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ (fun x => 1) =ᶠ[nhds a] ↑SignType.sign

tactic: exact ⟨{ x | 0 < x }, fun x hx => (sign_pos hx).symm, isOpen_lt' 0, h⟩
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : 0 < a
⊢ ∃ t, (∀ (x : α), x ∈ t → 1 = ↑SignType.sign x) ∧ IsOpen t ∧ a ∈ t
Theorem: MvPolynomial.hom_bind₁
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: rw [bind₁, map_aeval, algebraMap_eq]
state_before: σ : Type u_4
τ : Type u_2
R : Type u_1
S : Type u_3
T : Type ?u.758101
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : MvPolynomial τ R →+* S
g : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ ↑f (↑(bind₁ g) φ) = ↑(eval₂Hom (RingHom.comp f C) fun i => ↑f (g i)) φ
Theorem: Ideal.radical_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine le_antisymm ?_ fun r ⟨⟨m, hrm⟩, ⟨n, hrn⟩⟩ =>
  ⟨m + n, (pow_add r m n).symm ▸ mul_mem_mul hrm hrn⟩
state_before: R : Type u
ι : Type ?u.325271
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ radical (I * J) = radical I ⊓ radical J

tactic: have := radical_mono <| @mul_le_inf _ _ I J
state_before: R : Type u
ι : Type ?u.325271
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ radical (I * J) ≤ radical I ⊓ radical J

tactic: simp_rw [radical_inf I J] at this
state_before: R : Type u
ι : Type ?u.325271
inst✝ : CommSemiring R
I J K L : Ideal R
this : radical (I * J) ≤ radical (I ⊓ J)
⊢ radical (I * J) ≤ radical I ⊓ radical J

tactic: assumption
state_before: R : Type u
ι : Type ?u.325271
inst✝ : CommSemiring R
I J K L : Ideal R
this : radical (I * J) ≤ radical I ⊓ radical J
⊢ radical (I * J) ≤ radical I ⊓ radical J
Theorem: Nat.ord_proj_of_not_prime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization_eq_zero_of_non_prime n hp]
state_before: n p : ℕ
hp : ¬Prime p
⊢ p ^ ↑(factorization n) p = 1
Theorem: AddCommGroup.modEq_sub_iff_add_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: rw [add_comm]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ c + a ≡ b [PMOD p] ↔ a + c ≡ b [PMOD p]
Theorem: Set.ite_compl
File: Mathlib/Data/Set/Basic.lean

tactic: rw [Set.ite, Set.ite, diff_compl, union_comm, diff_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u t s s' : Set α
⊢ Set.ite (tᶜ) s s' = Set.ite t s' s
Theorem: Fin.lt_sub_one_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases k with ⟨_ | k, hk⟩
state_before: n✝ m n : ℕ
k : Fin (n + 2)
⊢ k < k - 1 ↔ k = 0

tactic: simp [lt_iff_val_lt_val]
state_before: case mk.zero
n✝ m n : ℕ
hk : zero < n + 2
⊢ { val := zero, isLt := hk } < { val := zero, isLt := hk } - 1 ↔ { val := zero, isLt := hk } = 0

case mk.succ
n✝ m n k : ℕ
hk : Nat.succ k < n + 2
⊢ { val := Nat.succ k, isLt := hk } < { val := Nat.succ k, isLt := hk } - 1 ↔ { val := Nat.succ k, isLt := hk } = 0

tactic: have : (k + 1 + (n + 1)) % (n + 2) = k % (n + 2) := by
  rw [add_right_comm, add_assoc, add_mod_right]
state_before: case mk.succ
n✝ m n k : ℕ
hk : Nat.succ k < n + 2
⊢ { val := Nat.succ k, isLt := hk } < { val := Nat.succ k, isLt := hk } - 1 ↔ { val := Nat.succ k, isLt := hk } = 0

tactic: simp [lt_iff_val_lt_val, ext_iff, Fin.coe_sub, succ_eq_add_one, this,
  mod_eq_of_lt ((lt_succ_self _).trans hk)]
state_before: case mk.succ
n✝ m n k : ℕ
hk : Nat.succ k < n + 2
this : (k + 1 + (n + 1)) % (n + 2) = k % (n + 2)
⊢ { val := Nat.succ k, isLt := hk } < { val := Nat.succ k, isLt := hk } - 1 ↔ { val := Nat.succ k, isLt := hk } = 0

tactic: rw [add_right_comm, add_assoc, add_mod_right]
state_before: n✝ m n k : ℕ
hk : Nat.succ k < n + 2
⊢ (k + 1 + (n + 1)) % (n + 2) = k % (n + 2)
Theorem: sub_orthogonalProjection_mem_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: intro w hw
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.498264
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
v : E
⊢ v - ↑(↑(orthogonalProjection K) v) ∈ Kᗮ

tactic: rw [inner_eq_zero_symm]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.498264
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
v w : E
hw : w ∈ K
⊢ inner w (v - ↑(↑(orthogonalProjection K) v)) = 0

tactic: exact orthogonalProjection_inner_eq_zero _ _ hw
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.498264
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
v w : E
hw : w ∈ K
⊢ inner (v - ↑(↑(orthogonalProjection K) v)) w = 0
Theorem: inv_gold
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: have : 1 + Real.sqrt 5 ≠ 0 := ne_of_gt (add_pos (by norm_num) <| Real.sqrt_pos.mpr (by norm_num))
state_before: ⊢ φ⁻¹ = -ψ

tactic: field_simp [sub_mul, mul_add]
state_before: this : 1 + sqrt 5 ≠ 0
⊢ φ⁻¹ = -ψ

tactic: norm_num
state_before: this : 1 + sqrt 5 ≠ 0
⊢ 2 * 2 = sqrt 5 * sqrt 5 - 1

tactic: norm_num
state_before: ⊢ 0 < 1

tactic: norm_num
state_before: ⊢ 0 < 5
Theorem: Nat.ArithmeticFunction.IsMultiplicative.int_cast
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [h]
state_before: R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
h : IsMultiplicative f
⊢ ↑↑f 1 = 1

tactic: cases h
state_before: R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
h : IsMultiplicative f
m n : ℕ
cop : coprime m n
⊢ ↑↑f (m * n) = ↑↑f m * ↑↑f n

tactic: rename_i j h
state_before: case intro
R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
m n : ℕ
cop : coprime m n
left✝ : ↑f 1 = 1
right✝ : ∀ {m n : ℕ}, coprime m n → ↑f (m * n) = ↑f m * ↑f n
⊢ ↑↑f (m * n) = ↑↑f m * ↑↑f n

tactic: simp [h cop]
state_before: case intro
R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
m n : ℕ
cop : coprime m n
j : ↑f 1 = 1
h : ∀ {m n : ℕ}, coprime m n → ↑f (m * n) = ↑f m * ↑f n
⊢ ↑↑f (m * n) = ↑↑f m * ↑↑f n
Theorem: isClosed_sum_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp only [← isOpen_compl_iff, isOpen_sum_iff, preimage_compl]
state_before: α : Type u
β : Type v
γ : Type ?u.119189
δ : Type ?u.119192
ε : Type ?u.119195
ζ : Type ?u.119198
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
s : Set (α ⊕ β)
⊢ IsClosed s ↔ IsClosed (inl ⁻¹' s) ∧ IsClosed (inr ⁻¹' s)