tasksource/leandojo huggingface dataset:
Theorem: tsum_mul_right
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simp [ha]
state_before: ι : Type u_2
κ : Type ?u.19284
R : Type ?u.19287
α : Type u_1
inst✝³ : DivisionSemiring α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
inst✝ : T2Space α
hf : ¬Summable f
ha : a = 0
⊢ (∑' (x : ι), f x * a) = (∑' (x : ι), f x) * a

tactic: rw [tsum_eq_zero_of_not_summable hf,
    tsum_eq_zero_of_not_summable (mt (summable_mul_right_iff ha).mp hf), zero_mul]
state_before: ι : Type u_2
κ : Type ?u.19284
R : Type ?u.19287
α : Type u_1
inst✝³ : DivisionSemiring α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
inst✝ : T2Space α
hf : ¬Summable f
ha : ¬a = 0
⊢ (∑' (x : ι), f x * a) = (∑' (x : ι), f x) * a
Theorem: Polynomial.comp_X
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp only [comp, eval₂_def, C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp p X = p

tactic: exact sum_monomial_eq _
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ (sum p fun e a => ↑(monomial e) a) = p
Theorem: Int.lt_neg_add_of_add_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_left h (-a)
state_before: a b c : Int
h : a + b < c
⊢ b < -a + c

tactic: rwa [Int.neg_add_cancel_left] at h
state_before: a b c : Int
h✝ : a + b < c
h : -a + (a + b) < -a + c
⊢ b < -a + c
Theorem: Nat.mod_eq_iff_lt
File: Mathlib/Data/Nat/Basic.lean

tactic: cases b
state_before: m n k a b : ℕ
h : b ≠ 0
⊢ a % b = a ↔ a < b

tactic: contradiction
state_before: case zero
m n k a : ℕ
h : zero ≠ 0
⊢ a % zero = a ↔ a < zero

case succ
m n k a n✝ : ℕ
h : succ n✝ ≠ 0
⊢ a % succ n✝ = a ↔ a < succ n✝

tactic: exact ⟨fun h => h.ge.trans_lt (mod_lt _ (succ_pos _)), mod_eq_of_lt⟩
state_before: case succ
m n k a n✝ : ℕ
h : succ n✝ ≠ 0
⊢ a % succ n✝ = a ↔ a < succ n✝
Theorem: Int.subNatNat_add_add
File: Std/Data/Int/Lemmas.lean

tactic: apply subNatNat_elim m n (fun m n i => subNatNat (m + k) (n + k) = i)
state_before: m n k : Nat
⊢ subNatNat (m + k) (n + k) = subNatNat m n

tactic: intro i j
state_before: case hp
m n k : Nat
⊢ ∀ (i n : Nat), subNatNat (n + i + k) (n + k) = ↑i

tactic: rw [Nat.add_assoc, Nat.add_comm i k, ← Nat.add_assoc]
state_before: case hp
m n k i j : Nat
⊢ subNatNat (j + i + k) (j + k) = ↑i

tactic: exact subNatNat_add_left
state_before: case hp
m n k i j : Nat
⊢ subNatNat (j + k + i) (j + k) = ↑i

tactic: intro i j
state_before: case hn
m n k : Nat
⊢ ∀ (i m : Nat), subNatNat (m + k) (m + i + 1 + k) = -[i+1]

tactic: rw [Nat.add_assoc j i 1, Nat.add_comm j (i+1), Nat.add_assoc, Nat.add_comm (i+1) (j+k)]
state_before: case hn
m n k i j : Nat
⊢ subNatNat (j + k) (j + i + 1 + k) = -[i+1]

tactic: exact subNatNat_add_right
state_before: case hn
m n k i j : Nat
⊢ subNatNat (j + k) (j + k + (i + 1)) = -[i+1]
Theorem: Finset.Nat.gcd_div_eq_one
File: Mathlib/Algebra/GCDMonoid/Div.lean

tactic: obtain ⟨g, he, hg⟩ := Finset.extract_gcd f ⟨x, hx⟩
state_before: β : Type u_1
f : β → ℕ
s : Finset β
x : β
hx : x ∈ s
hfz : f x ≠ 0
⊢ (gcd s fun b => f b / gcd s f) = 1

tactic: refine' (Finset.gcd_congr rfl fun a ha => _).trans hg
state_before: case intro.intro
β : Type u_1
f : β → ℕ
s : Finset β
x : β
hx : x ∈ s
hfz : f x ≠ 0
g : β → ℕ
he : ∀ (b : β), b ∈ s → f b = gcd s f * g b
hg : gcd s g = 1
⊢ (gcd s fun b => f b / gcd s f) = 1

tactic: rw [he a ha, Nat.mul_div_cancel_left]
state_before: case intro.intro
β : Type u_1
f : β → ℕ
s : Finset β
x : β
hx : x ∈ s
hfz : f x ≠ 0
g : β → ℕ
he : ∀ (b : β), b ∈ s → f b = gcd s f * g b
hg : gcd s g = 1
a : β
ha : a ∈ s
⊢ f a / gcd s f = g a

tactic: exact Nat.pos_of_ne_zero (mt Finset.gcd_eq_zero_iff.1 fun h => hfz <| h x hx)
state_before: case intro.intro.H
β : Type u_1
f : β → ℕ
s : Finset β
x : β
hx : x ∈ s
hfz : f x ≠ 0
g : β → ℕ
he : ∀ (b : β), b ∈ s → f b = gcd s f * g b
hg : gcd s g = 1
a : β
ha : a ∈ s
⊢ 0 < gcd s f
Theorem: inner_orthogonalProjection_left_eq_right
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [← inner_orthogonalProjection_eq_of_mem_left, inner_orthogonalProjection_eq_of_mem_right]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.981861
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
u v : E
⊢ inner (↑(↑(orthogonalProjection K) u)) v = inner u ↑(↑(orthogonalProjection K) v)
Theorem: SimpleGraph.Walk.length_reverseAux
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp!
| cons _ _ ih => simp [ih, Nat.add_succ, Nat.succ_add]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
q : Walk G u w
⊢ length (Walk.reverseAux p q) = length p + length q

tactic: simp!
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ : V
q : Walk G u✝ w
⊢ length (Walk.reverseAux nil q) = length nil + length q

tactic: simp [ih, Nat.add_succ, Nat.succ_add]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (q : Walk G v✝ w), length (Walk.reverseAux p✝ q) = length p✝ + length q
q : Walk G u✝ w
⊢ length (Walk.reverseAux (cons h✝ p✝) q) = length (cons h✝ p✝) + length q
Theorem: SimpleGraph.neighborFinset_compl
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp only [neighborFinset, neighborSet_compl, Set.toFinset_diff, Set.toFinset_compl,
  Set.toFinset_singleton]
state_before: ι : Sort ?u.283769
𝕜 : Type ?u.283772
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableEq V
inst✝ : DecidableRel G.Adj
v : V
⊢ neighborFinset (Gᶜ) v = neighborFinset G vᶜ \ {v}
Theorem: padicValInt.of_ne_one_ne_zero
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: apply multiplicity.finite_int_iff.2
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ (multiplicity (↑p) z).Dom

tactic: simp [hp, hz]
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ Int.natAbs ↑p ≠ 1 ∧ z ≠ 0

tactic: rw [padicValInt, padicValNat, dif_pos (And.intro hp (Int.natAbs_pos.mpr hz))]
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ padicValInt p z = Part.get (multiplicity (↑p) z) (_ : multiplicity.Finite (↑p) z)

tactic: simp only [multiplicity.Int.natAbs p z]
state_before: p : ℕ
z : ℤ
hp : p ≠ 1
hz : z ≠ 0
⊢ Part.get (multiplicity p (Int.natAbs z)) (_ : multiplicity.Finite p (Int.natAbs z)) =
    Part.get (multiplicity (↑p) z) (_ : multiplicity.Finite (↑p) z)
Theorem: lt_mul_iff_one_lt_left
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rw [one_mul]
state_before: α : Type u_1
a b c d : α
inst✝⁴ : MulOneClass α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : MulPosStrictMono α
inst✝ : MulPosReflectLT α
a0 : 0 < a
⊢ a < b * a ↔ 1 * a < b * a
Theorem: sbtw_zero_one_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Sbtw, wbtw_zero_one_iff, Set.mem_Icc, Set.mem_Ioo]
state_before: R : Type u_1
V : Type ?u.266529
V' : Type ?u.266532
P : Type ?u.266535
P' : Type ?u.266538
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ Sbtw R 0 x 1 ↔ x ∈ Set.Ioo 0 1

tactic: exact
  ⟨fun h => ⟨h.1.1.lt_of_ne (Ne.symm h.2.1), h.1.2.lt_of_ne h.2.2⟩, fun h =>
    ⟨⟨h.1.le, h.2.le⟩, h.1.ne', h.2.ne⟩⟩
state_before: R : Type u_1
V : Type ?u.266529
V' : Type ?u.266532
P : Type ?u.266535
P' : Type ?u.266538
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (0 ≤ x ∧ x ≤ 1) ∧ x ≠ 0 ∧ x ≠ 1 ↔ 0 < x ∧ x < 1
Theorem: SimpleGraph.FarFromTriangleFree.nonpos
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean

tactic: have := h₀ (empty_subset _)
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : Fintype α
inst✝¹ : LinearOrderedField 𝕜
G H : SimpleGraph α
ε δ : 𝕜
n : ℕ
s : Finset α
inst✝ : Nonempty α
h₀ : FarFromTriangleFree G ε
h₁ : CliqueFree G 3
⊢ ε ≤ 0

tactic: rw [coe_empty, Finset.card_empty, cast_zero, deleteEdges_empty_eq] at this
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : Fintype α
inst✝¹ : LinearOrderedField 𝕜
G H : SimpleGraph α
ε δ : 𝕜
n : ℕ
s : Finset α
inst✝ : Nonempty α
h₀ : FarFromTriangleFree G ε
h₁ : CliqueFree G 3
this : (fun H => CliqueFree H 3) (deleteEdges G ↑∅) → ε * ↑(Fintype.card α ^ 2) ≤ ↑(Finset.card ∅)
⊢ ε ≤ 0

tactic: exact nonpos_of_mul_nonpos_left (this h₁) (cast_pos.2 <| sq_pos_of_pos Fintype.card_pos)
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : Fintype α
inst✝¹ : LinearOrderedField 𝕜
G H : SimpleGraph α
ε δ : 𝕜
n : ℕ
s : Finset α
inst✝ : Nonempty α
h₀ : FarFromTriangleFree G ε
h₁ : CliqueFree G 3
this : (fun H => CliqueFree H 3) G → ε * ↑(Fintype.card α ^ 2) ≤ 0
⊢ ε ≤ 0
Theorem: CategoryTheory.exact_d_f
File: Mathlib/CategoryTheory/Abelian/Projective.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
inst✝ : EnoughProjectives C
X Y : C
f : X ⟶ Y
⊢ d f ≫ f = 0

tactic: rw [← Category.assoc, cokernel.condition]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
inst✝ : EnoughProjectives C
X Y : C
f : X ⟶ Y
⊢ π (kernel f) ≫ kernel.ι f ≫ cokernel.π (d f) = 0
Theorem: ContDiffBump.pos_of_mem_ball
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: rwa [← support_eq, mem_support] at hx
state_before: E : Type u_1
X : Type ?u.89198
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
hx : x ∈ ball c f.rOut
⊢ ↑f x ≠ 0
Theorem: Ideal.polynomialQuotientEquivQuotientPolynomial_map_mk
File: Mathlib/RingTheory/Polynomial/Quotient.lean

tactic: apply (polynomialQuotientEquivQuotientPolynomial I).symm.injective
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
f : R[X]
⊢ ↑(polynomialQuotientEquivQuotientPolynomial I) (Polynomial.map (Quotient.mk I) f) = ↑(Quotient.mk (map C I)) f

tactic: rw [RingEquiv.symm_apply_apply, polynomialQuotientEquivQuotientPolynomial_symm_mk]
state_before: case a
R : Type u_1
inst✝ : CommRing R
I : Ideal R
f : R[X]
⊢ ↑(RingEquiv.symm (polynomialQuotientEquivQuotientPolynomial I))
      (↑(polynomialQuotientEquivQuotientPolynomial I) (Polynomial.map (Quotient.mk I) f)) =
    ↑(RingEquiv.symm (polynomialQuotientEquivQuotientPolynomial I)) (↑(Quotient.mk (map C I)) f)
Theorem: iSup_ge_eq_iSup_nat_add
File: Mathlib/Order/CompleteLattice.lean

tactic: apply le_antisymm <;> simp only [iSup_le_iff]
state_before: α : Type u_1
β : Type ?u.176393
β₂ : Type ?u.176396
γ : Type ?u.176399
ι : Sort ?u.176402
ι' : Sort ?u.176405
κ : ι → Sort ?u.176410
κ' : ι' → Sort ?u.176415
inst✝ : CompleteLattice α
f g s t : ι → α
a b : α
u : ℕ → α
n : ℕ
⊢ (⨆ (i : ℕ) (_ : i ≥ n), u i) = ⨆ (i : ℕ), u (i + n)

tactic: refine fun i hi => le_sSup ⟨i - n, ?_⟩
state_before: case a
α : Type u_1
β : Type ?u.176393
β₂ : Type ?u.176396
γ : Type ?u.176399
ι : Sort ?u.176402
ι' : Sort ?u.176405
κ : ι → Sort ?u.176410
κ' : ι' → Sort ?u.176415
inst✝ : CompleteLattice α
f g s t : ι → α
a b : α
u : ℕ → α
n : ℕ
⊢ ∀ (i : ℕ), i ≥ n → u i ≤ ⨆ (i : ℕ), u (i + n)

tactic: dsimp only
state_before: case a
α : Type u_1
β : Type ?u.176393
β₂ : Type ?u.176396
γ : Type ?u.176399
ι : Sort ?u.176402
ι' : Sort ?u.176405
κ : ι → Sort ?u.176410
κ' : ι' → Sort ?u.176415
inst✝ : CompleteLattice α
f g s t : ι → α
a b : α
u : ℕ → α
n i : ℕ
hi : i ≥ n
⊢ (fun i => u (i + n)) (i - n) = u i

tactic: rw [Nat.sub_add_cancel hi]
state_before: case a
α : Type u_1
β : Type ?u.176393
β₂ : Type ?u.176396
γ : Type ?u.176399
ι : Sort ?u.176402
ι' : Sort ?u.176405
κ : ι → Sort ?u.176410
κ' : ι' → Sort ?u.176415
inst✝ : CompleteLattice α
f g s t : ι → α
a b : α
u : ℕ → α
n i : ℕ
hi : i ≥ n
⊢ u (i - n + n) = u i

tactic: exact fun i => le_sSup ⟨i + n, iSup_pos (Nat.le_add_left _ _)⟩
state_before: case a
α : Type u_1
β : Type ?u.176393
β₂ : Type ?u.176396
γ : Type ?u.176399
ι : Sort ?u.176402
ι' : Sort ?u.176405
κ : ι → Sort ?u.176410
κ' : ι' → Sort ?u.176415
inst✝ : CompleteLattice α
f g s t : ι → α
a b : α
u : ℕ → α
n : ℕ
⊢ ∀ (i : ℕ), u (i + n) ≤ ⨆ (i : ℕ) (_ : i ≥ n), u i
Theorem: multiplicity.finite_of_finite_mul_left
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [mul_comm]
state_before: α : Type u_1
inst✝ : CommMonoid α
a b c : α
⊢ Finite a (b * c) → Finite a c

tactic: exact finite_of_finite_mul_right
state_before: α : Type u_1
inst✝ : CommMonoid α
a b c : α
⊢ Finite a (c * b) → Finite a c
Theorem: Polynomial.derivative_C_mul_X_pow
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [C_mul_X_pow_eq_monomial, C_mul_X_pow_eq_monomial, derivative_monomial]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a✝ b : R
n✝ : ℕ
inst✝ : Semiring R
a : R
n : ℕ
⊢ ↑derivative (↑C a * X ^ n) = ↑C (a * ↑n) * X ^ (n - 1)
Theorem: Finsupp.single_eq_same
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical exact Pi.single_eq_same (f := λ _ => M) a b
state_before: α : Type u_2
β : Type ?u.40853
γ : Type ?u.40856
ι : Type ?u.40859
M : Type u_1
M' : Type ?u.40865
N : Type ?u.40868
P : Type ?u.40871
G : Type ?u.40874
H : Type ?u.40877
R : Type ?u.40880
S : Type ?u.40883
inst✝ : Zero M
a a' : α
b : M
⊢ ↑(single a b) a = b

tactic: exact Pi.single_eq_same (f := λ _ => M) a b
state_before: α : Type u_2
β : Type ?u.40853
γ : Type ?u.40856
ι : Type ?u.40859
M : Type u_1
M' : Type ?u.40865
N : Type ?u.40868
P : Type ?u.40871
G : Type ?u.40874
H : Type ?u.40877
R : Type ?u.40880
S : Type ?u.40883
inst✝ : Zero M
a a' : α
b : M
⊢ ↑(single a b) a = b
Theorem: IsCompactOperator.image_subset_compact_of_isVonNBounded
File: Mathlib/Analysis/NormedSpace/CompactOperator.lean

tactic: rw [image_subset_iff, preimage_smul_setₛₗ _ _ _ f this.isUnit]
state_before: 𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜₁
inst✝⁷ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_3
M₂ : Type u_4
inst✝⁶ : TopologicalSpace M₁
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ↑f
S : Set M₁
hS : IsVonNBounded 𝕜₁ S
K : Set M₂
hK : IsCompact K
hKf : ↑f ⁻¹' K ∈ 𝓝 0
r : ℝ
hr : 0 < r
hrS : ∀ (a : 𝕜₁), r ≤ ‖a‖ → S ⊆ a • ↑f ⁻¹' K
c : 𝕜₁
hc : r < ‖c‖
this : c ≠ 0 := ne_zero_of_norm_ne_zero (Ne.symm (LT.lt.ne (LT.lt.trans hr hc)))
⊢ ↑f '' S ⊆ ↑σ₁₂ c • K

tactic: exact hrS c hc.le
state_before: 𝕜₁ : Type u_1
𝕜₂ : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜₁
inst✝⁷ : SeminormedRing 𝕜₂
σ₁₂ : 𝕜₁ →+* 𝕜₂
M₁ : Type u_3
M₂ : Type u_4
inst✝⁶ : TopologicalSpace M₁
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : TopologicalSpace M₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module 𝕜₁ M₁
inst✝¹ : Module 𝕜₂ M₂
inst✝ : ContinuousConstSMul 𝕜₂ M₂
f : M₁ →ₛₗ[σ₁₂] M₂
hf : IsCompactOperator ↑f
S : Set M₁
hS : IsVonNBounded 𝕜₁ S
K : Set M₂
hK : IsCompact K
hKf : ↑f ⁻¹' K ∈ 𝓝 0
r : ℝ
hr : 0 < r
hrS : ∀ (a : 𝕜₁), r ≤ ‖a‖ → S ⊆ a • ↑f ⁻¹' K
c : 𝕜₁
hc : r < ‖c‖
this : c ≠ 0 := ne_zero_of_norm_ne_zero (Ne.symm (LT.lt.ne (LT.lt.trans hr hc)))
⊢ S ⊆ c • ↑f ⁻¹' K
Theorem: ZMod.ringChar_zmod_n
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [ringChar.eq_iff]
state_before: n : ℕ
⊢ ringChar (ZMod n) = n

tactic: exact ZMod.charP n
state_before: n : ℕ
⊢ CharP (ZMod n) n
Theorem: Language.mem_one
File: Mathlib/Computability/Language.lean

tactic: rfl
state_before: α : Type u_1
β : Type ?u.35758
γ : Type ?u.35761
l m : Language α
a b x✝ x : List α
⊢ x ∈ 1 ↔ x = []
Theorem: Rat.div_int_inj
File: Mathlib/Data/Rat/Lemmas.lean

tactic: apply And.intro
state_before: a b c d : ℤ
hb0 : 0 < b
hd0 : 0 < d
h1 : Nat.coprime (Int.natAbs a) (Int.natAbs b)
h2 : Nat.coprime (Int.natAbs c) (Int.natAbs d)
h : ↑a / ↑b = ↑c / ↑d
⊢ a = c ∧ b = d

tactic: rw [← num_div_eq_of_coprime hb0 h1, h, num_div_eq_of_coprime hd0 h2]
state_before: case left
a b c d : ℤ
hb0 : 0 < b
hd0 : 0 < d
h1 : Nat.coprime (Int.natAbs a) (Int.natAbs b)
h2 : Nat.coprime (Int.natAbs c) (Int.natAbs d)
h : ↑a / ↑b = ↑c / ↑d
⊢ a = c

tactic: rw [← den_div_eq_of_coprime hb0 h1, h, den_div_eq_of_coprime hd0 h2]
state_before: case right
a b c d : ℤ
hb0 : 0 < b
hd0 : 0 < d
h1 : Nat.coprime (Int.natAbs a) (Int.natAbs b)
h2 : Nat.coprime (Int.natAbs c) (Int.natAbs d)
h : ↑a / ↑b = ↑c / ↑d
⊢ b = d
Theorem: Lagrange.nodal_insert_eq_nodal
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [nodal, prod_insert hi]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hi : ¬i ∈ s
⊢ nodal (insert i s) v = (X - ↑C (v i)) * nodal s v
Theorem: Finset.prod_flip
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: induction' n with n ih
state_before: ι : Type ?u.711041
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
n : ℕ
f : ℕ → β
⊢ ∏ r in range (n + 1), f (n - r) = ∏ k in range (n + 1), f k

tactic: rw [prod_range_one, prod_range_one]
state_before: case zero
ι : Type ?u.711041
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
⊢ ∏ r in range (Nat.zero + 1), f (Nat.zero - r) = ∏ k in range (Nat.zero + 1), f k

tactic: rw [prod_range_succ', prod_range_succ _ (Nat.succ n)]
state_before: case succ
ι : Type ?u.711041
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
ih : ∏ r in range (n + 1), f (n - r) = ∏ k in range (n + 1), f k
⊢ ∏ r in range (Nat.succ n + 1), f (Nat.succ n - r) = ∏ k in range (Nat.succ n + 1), f k

tactic: simp [← ih]
state_before: case succ
ι : Type ?u.711041
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
ih : ∏ r in range (n + 1), f (n - r) = ∏ k in range (n + 1), f k
⊢ (∏ k in range (n + 1), f (Nat.succ n - (k + 1))) * f (Nat.succ n - 0) =
    (∏ x in range (Nat.succ n), f x) * f (Nat.succ n)
Theorem: Multiset.pairwise_coe_iff
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.515659
γ : Type ?u.515662
r : α → α → Prop
l : List α
⊢ ∀ (a : List α), ↑l = ↑a ∧ List.Pairwise r a ↔ l ~ a ∧ List.Pairwise r a
Theorem: Filter.nhds_nhds
File: Mathlib/Topology/Filter.lean

tactic: simp only [(nhds_basis_opens x).nhds.eq_biInf, iInf_and, @iInf_comm _ (_ ∈ _)]
state_before: ι : Sort ?u.21870
α : Type ?u.21873
β : Type ?u.21876
X : Type u_1
Y : Type ?u.21882
inst✝ : TopologicalSpace X
x : X
⊢ 𝓝 (𝓝 x) = ⨅ (s : Set X) (_ : IsOpen s) (_ : x ∈ s), 𝓟 (Iic (𝓟 s))
Theorem: MeasureTheory.measure_isOpen_pos_of_smulInvariant_of_compact_ne_zero
File: Mathlib/MeasureTheory/Group/Action.lean

tactic: rwa [measure_smul]
state_before: G : Type ?u.52553
M : Type ?u.52556
α : Type u_1
s : Set α
m : MeasurableSpace α
inst✝⁷ : Group G
inst✝⁶ : MulAction G α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
c : G
μ : Measure α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousConstSMul G α
inst✝ : MulAction.IsMinimal G α
K U : Set α
hK : IsCompact K
hμK : ↑↑μ K ≠ 0
hU : IsOpen U
hne : Set.Nonempty U
t : Finset G
ht : K ⊆ ⋃ (g : G) (_ : g ∈ t), g • U
hμU : ↑↑μ U = 0
x✝¹ : G
x✝ : x✝¹ ∈ ↑t
⊢ ↑↑μ (x✝¹ • U) = 0
Theorem: Finset.image_add_left_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← map_add_left_Icc, map_eq_image]
state_before: ι : Type ?u.233124
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image ((fun x x_1 => x + x_1) c) (Icc a b) = Icc (c + a) (c + b)

tactic: rfl
state_before: ι : Type ?u.233124
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image ((fun x x_1 => x + x_1) c) (Icc a b) = image (↑(addLeftEmbedding c)) (Icc a b)
Theorem: ack_add_one_sq_lt_ack_add_four
File: Mathlib/Computability/Ackermann.lean

tactic: linarith
state_before: m n : ℕ
⊢ m ≤ m + 2
Theorem: Submonoid.LocalizationMap.lift_of_comp
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: ext
state_before: M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
⊢ lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(MonoidHom.comp j (toMap f)) ↑y)) = j

tactic: rw [lift_spec]
state_before: case h
M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
x✝ : N
⊢ ↑(lift f (_ : ∀ (y : { x // x ∈ S }), IsUnit (↑(MonoidHom.comp j (toMap f)) ↑y))) x✝ = ↑j x✝

tactic: show j _ = j _ * _
state_before: case h
M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
x✝ : N
⊢ ↑(MonoidHom.comp j (toMap f)) (sec f x✝).fst = ↑(MonoidHom.comp j (toMap f)) ↑(sec f x✝).snd * ↑j x✝

tactic: erw [← j.map_mul, sec_spec']
state_before: case h
M : Type u_3
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type u_2
inst✝ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
j : N →* P
x✝ : N
⊢ ↑j (↑(toMap f) (sec f x✝).fst) = ↑j (↑(toMap f) ↑(sec f x✝).snd) * ↑j x✝
Theorem: nhdsSet_eq_principal_iff
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [← principal_le_nhdsSet.le_iff_eq, le_principal_iff, mem_nhdsSet_iff_forall,
  isOpen_iff_mem_nhds]
state_before: α : Type u_1
β : Type ?u.11427
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
⊢ 𝓝ˢ s = 𝓟 s ↔ IsOpen s
Theorem: AddGroupSeminorm.smul_sup
File: Mathlib/Analysis/Normed/Group/Seminorm.lean

tactic: simpa only [← smul_eq_mul, ← NNReal.smul_def, smul_one_smul ℝ≥0 r (_ : ℝ)] using
  mul_max_of_nonneg x y (r • (1 : ℝ≥0) : ℝ≥0).coe_nonneg
state_before: ι : Type ?u.123700
R : Type u_2
R' : Type ?u.123706
E : Type u_1
F : Type ?u.123712
G : Type ?u.123715
inst✝³ : AddGroup E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
p✝ : AddGroupSeminorm E
r : R
p q : AddGroupSeminorm E
x y : ℝ
⊢ r • max x y = max (r • x) (r • y)
Theorem: Real.sqrt_inv
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sqrt, Real.toNNReal_inv, NNReal.sqrt_inv, NNReal.coe_inv, sqrt]
state_before: x : ℝ
⊢ sqrt x⁻¹ = (sqrt x)⁻¹
Theorem: LieModuleHom.map_top
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: ext
state_before: R : Type u
L : Type v
M : Type w
N : 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
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
⊢ LieSubmodule.map f ⊤ = range f

tactic: simp [LieSubmodule.mem_map]
state_before: case h
R : Type u
L : Type v
M : Type w
N : 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
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
m✝ : N
⊢ m✝ ∈ LieSubmodule.map f ⊤ ↔ m✝ ∈ range f
Theorem: YoungDiagram.colLen_eq_card
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp [col_eq_prod]
state_before: μ : YoungDiagram
j : ℕ
⊢ colLen μ j = Finset.card (col μ j)
Theorem: div_right_injective
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [div_eq_mul_inv]
state_before: α : Type ?u.56480
β : Type ?u.56483
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ Injective fun a => b / a

tactic: exact fun a a' h ↦ inv_injective (mul_right_injective b h)
state_before: α : Type ?u.56480
β : Type ?u.56483
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ Injective fun a => b * a⁻¹