tasksource/leandojo huggingface dataset:
Theorem: PadicInt.zmod_congr_of_sub_mem_max_ideal
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: rw [maximalIdeal_eq_span_p] at hm hn
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ maximalIdeal ℤ_[p]
hn : x - ↑n ∈ maximalIdeal ℤ_[p]
⊢ ↑m = ↑n

tactic: have := zmod_congr_of_sub_mem_span_aux 1 x m n
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
⊢ ↑m = ↑n

tactic: simp only [pow_one] at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : x - ↑↑m ∈ Ideal.span {↑p ^ 1} → x - ↑↑n ∈ Ideal.span {↑p ^ 1} → ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: specialize this hm hn
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : x - ↑↑m ∈ Ideal.span {↑p} → x - ↑↑n ∈ Ideal.span {↑p} → ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: apply_fun ZMod.castHom (show p ∣ p ^ 1 by rw [pow_one]) (ZMod p)  at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: simp only [map_intCast] at this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑(ZMod.castHom (_ : p ∣ p ^ 1) (ZMod p)) ↑↑m = ↑(ZMod.castHom (_ : p ∣ p ^ 1) (ZMod p)) ↑↑n
⊢ ↑m = ↑n

tactic: simpa only [Int.cast_ofNat] using this
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ ↑m = ↑n

tactic: rw [pow_one]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
m n : ℕ
hm : x - ↑m ∈ Ideal.span {↑p}
hn : x - ↑n ∈ Ideal.span {↑p}
this : ↑↑m = ↑↑n
⊢ p ∣ p ^ 1
Theorem: Nat.card_multiples
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: induction' n with n hn
state_before: n p : ℕ
⊢ card (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)) = n / p

tactic: simp [Nat.succ_div, add_ite, add_zero, Finset.range_succ, filter_insert, apply_ite card,
  card_insert_of_not_mem, hn]
state_before: case succ
p n : ℕ
hn : card (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)) = n / p
⊢ card (Finset.filter (fun e => p ∣ e + 1) (Finset.range (succ n))) = succ n / p

tactic: simp
state_before: case zero
p : ℕ
⊢ card (Finset.filter (fun e => p ∣ e + 1) (Finset.range zero)) = zero / p
Theorem: Ideal.mul_sub_mul_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [show a * c - b * d = (a - b) * c + b * (c - d) by rw [sub_mul, mul_sub]; abel]
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d ∈ I

tactic: exact I.add_mem (I.mul_mem_right _ h1) (I.mul_mem_left _ h2)
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ (a - b) * c + b * (c - d) ∈ I

tactic: rw [sub_mul, mul_sub]
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d = (a - b) * c + b * (c - d)

tactic: abel
state_before: α : Type u
β : Type v
R : Type u_1
inst✝ : CommRing R
I : Ideal R
a b c d : R
h1 : a - b ∈ I
h2 : c - d ∈ I
⊢ a * c - b * d = a * c - b * c + (b * c - b * d)
Theorem: vadd_eq_vadd_iff_neg_add_eq_vsub
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [eq_vadd_iff_vsub_eq, vadd_vsub_assoc, ← add_right_inj (-v₁), neg_add_cancel_left, eq_comm]
state_before: G : Type u_2
P : Type u_1
inst✝ : AddGroup G
T : AddTorsor G P
v₁ v₂ : G
p₁ p₂ : P
⊢ v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ -v₁ + v₂ = p₁ -ᵥ p₂
Theorem: IsSubgroup.mul_mem_cancel_left
File: Mathlib/Deprecated/Subgroup.lean

tactic: simpa using hs.mul_mem (hs.inv_mem h) hab
state_before: G : Type u_1
H : Type ?u.14510
A : Type ?u.14513
a a₁ a₂ b c : G
inst✝ : Group G
s : Set G
hs : IsSubgroup s
h : a ∈ s
hab : a * b ∈ s
⊢ b ∈ s
Theorem: Submodule.map_inl
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext ⟨x, y⟩
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.292947
M₆ : Type ?u.292950
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (inl R M M₂) p = prod p ⊥

tactic: simp only [and_left_comm, eq_comm, mem_map, Prod.mk.inj_iff, inl_apply, mem_bot, exists_eq_left',
  mem_prod]
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.292947
M₆ : Type ?u.292950
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ map (inl R M M₂) p ↔ (x, y) ∈ prod p ⊥
Theorem: ContDiffWithinAt.div
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul (hg.inv hx)
state_before: 𝕜 : Type u_1
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type ?u.2669110
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
R : Type ?u.2672588
inst✝⁵ : NormedRing R
inst✝⁴ : NormedAlgebra 𝕜 R
𝕜' : Type ?u.2672657
inst✝³ : NormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : CompleteSpace 𝕜'
inst✝ : CompleteSpace 𝕜
f g : E → 𝕜
n : ℕ∞
hf : ContDiffWithinAt 𝕜 n f s x
hg : ContDiffWithinAt 𝕜 n g s x
hx : g x ≠ 0
⊢ ContDiffWithinAt 𝕜 n (fun x => f x / g x) s x
Theorem: Dfinsupp.coe_tsub
File: Mathlib/Data/Dfinsupp/Order.lean

tactic: ext i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → CanonicallyOrderedAddMonoid (α i)
inst✝¹ : (i : ι) → Sub (α i)
inst✝ : ∀ (i : ι), OrderedSub (α i)
f✝ g✝ : Π₀ (i : ι), α i
i : ι
a b : α i
f g : Π₀ (i : ι), α i
⊢ ↑(f - g) = ↑f - ↑g

tactic: exact tsub_apply f g i
state_before: case h
ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → CanonicallyOrderedAddMonoid (α i)
inst✝¹ : (i : ι) → Sub (α i)
inst✝ : ∀ (i : ι), OrderedSub (α i)
f✝ g✝ : Π₀ (i : ι), α i
i✝ : ι
a b : α i✝
f g : Π₀ (i : ι), α i
i : ι
⊢ ↑(f - g) i = (↑f - ↑g) i
Theorem: nilradical_eq_sInf
File: Mathlib/RingTheory/Nilpotent.lean

tactic: simp_rw [and_iff_right bot_le]
state_before: R✝ S : Type u
x y : R✝
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : CommSemiring R
⊢ sInf {J | ⊥ ≤ J ∧ Ideal.IsPrime J} = sInf {J | Ideal.IsPrime J}
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.eq_top_iff_isIso
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: constructor
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
⊢ G = ⊤ ↔ IsIso (ι G)

tactic: rintro rfl
state_before: case mp
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
⊢ G = ⊤ → IsIso (ι G)

tactic: infer_instance
state_before: case mp
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G' : Subpresheaf F
⊢ IsIso (ι ⊤)

tactic: intro H
state_before: case mpr
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
⊢ IsIso (ι G) → G = ⊤

tactic: ext (U x)
state_before: case mpr
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
H : IsIso (ι G)
⊢ G = ⊤

tactic: apply iff_true_iff.mpr
state_before: case mpr.obj.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
H : IsIso (ι G)
U : Cᵒᵖ
x : F.obj U
⊢ x ∈ obj G U ↔ x ∈ obj ⊤ U

tactic: rw [← IsIso.inv_hom_id_apply (G.ι.app U) x]
state_before: case mpr.obj.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
H : IsIso (ι G)
U : Cᵒᵖ
x : F.obj U
⊢ x ∈ obj G U

tactic: exact ((inv (G.ι.app U)) x).2
state_before: case mpr.obj.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
H : IsIso (ι G)
U : Cᵒᵖ
x : F.obj U
⊢ (forget (Type w)).map ((ι G).app U)
      ((forget (Type w)).map
        (Classical.choose (_ : ∃ inv, (ι G).app U ≫ inv = 𝟙 ((toPresheaf G).obj U) ∧ inv ≫ (ι G).app U = 𝟙 (F.obj U)))
        x) ∈
    obj G U
Theorem: DiscreteQuotient.ofLE_refl
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: ext ⟨⟩
state_before: α : Type ?u.12863
X : Type u_1
Y : Type ?u.12869
Z : Type ?u.12872
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
⊢ ofLE (_ : A ≤ A) = id

tactic: rfl
state_before: case h.mk
α : Type ?u.12863
X : Type u_1
Y : Type ?u.12869
Z : Type ?u.12872
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
x✝ : Quotient A.toSetoid
a✝ : X
⊢ ofLE (_ : A ≤ A) (Quot.mk Setoid.r a✝) = id (Quot.mk Setoid.r a✝)
Theorem: Multiset.powersetAux'_cons
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetAux']
state_before: α : Type u_1
a : α
l : List α
⊢ powersetAux' (a :: l) = powersetAux' l ++ List.map (cons a) (powersetAux' l)

tactic: rfl
state_before: α : Type u_1
a : α
l : List α
⊢ List.map (ofList ∘ List.cons a) (sublists' l) = List.map (cons a ∘ ofList) (sublists' l)
Theorem: ProbabilityTheory.iIndepSet.indep_generateFrom_lt
File: Mathlib/Probability/Independence/Basic.lean

tactic: convert iIndepSet.indep_generateFrom_of_disjoint hsm hs {i} { j | j < i }
  (Set.disjoint_singleton_left.mpr (lt_irrefl _))
state_before: Ω : Type u_2
ι : Type u_1
m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝¹ : Preorder ι
inst✝ : IsProbabilityMeasure μ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s
i : ι
⊢ Indep (generateFrom {s i}) (generateFrom {t | ∃ j, j < i ∧ s j = t})

tactic: simp only [Set.mem_singleton_iff, exists_prop, exists_eq_left, Set.setOf_eq_eq_singleton']
state_before: case h.e'_2.h.e'_2
Ω : Type u_2
ι : Type u_1
m0 : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
inst✝¹ : Preorder ι
inst✝ : IsProbabilityMeasure μ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s
i : ι
⊢ {s i} = {t | ∃ n, n ∈ {i} ∧ s n = t}
Theorem: Finset.map_ofDual_max
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [min_eq_inf_withTop, inf_image]
state_before: F : Type ?u.347556
α : Type u_1
β : Type ?u.347562
γ : Type ?u.347565
ι : Type ?u.347568
κ : Type ?u.347571
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
⊢ WithBot.map (↑ofDual) (Finset.max s) = Finset.min (image (↑ofDual) s)

tactic: exact congr_fun Option.map_id _
state_before: F : Type ?u.347556
α : Type u_1
β : Type ?u.347562
γ : Type ?u.347565
ι : Type ?u.347568
κ : Type ?u.347571
inst✝ : LinearOrder α
s✝ : Finset α
H : Finset.Nonempty s✝
x : α
s : Finset αᵒᵈ
⊢ WithBot.map (↑ofDual) (Finset.max s) = inf s (WithTop.some ∘ ↑ofDual)
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_of_isIdempotentComplete_opposite
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: refine' ⟨_⟩
state_before: C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
⊢ IsIdempotentComplete C

tactic: intro X p hp
state_before: C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
⊢ ∀ (X : C) (p : X ⟶ X), p ≫ p = p → ∃ Y i e, i ≫ e = 𝟙 Y ∧ e ≫ i = p

tactic: rcases IsIdempotentComplete.idempotents_split (op X) p.op (by rw [← op_comp, hp]) with
  ⟨Y, i, e, ⟨h₁, h₂⟩⟩
state_before: C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
⊢ ∃ Y i e, i ≫ e = 𝟙 Y ∧ e ≫ i = p

tactic: use Y.unop, e.unop, i.unop
state_before: case intro.intro.intro.intro
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ X.op
e : X.op ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ ∃ Y i e, i ≫ e = 𝟙 Y ∧ e ≫ i = p

tactic: constructor
state_before: case intro.intro.intro.intro
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ X.op
e : X.op ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ e.unop ≫ i.unop = 𝟙 Y.unop ∧ i.unop ≫ e.unop = p

tactic: rw [← op_comp, hp]
state_before: C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
⊢ p.op ≫ p.op = p.op

tactic: simp only [← unop_comp, h₁]
state_before: case intro.intro.intro.intro.left
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ X.op
e : X.op ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ e.unop ≫ i.unop = 𝟙 Y.unop

tactic: rfl
state_before: case intro.intro.intro.intro.left
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ X.op
e : X.op ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ (𝟙 Y).unop = 𝟙 Y.unop

tactic: simp only [← unop_comp, h₂]
state_before: case intro.intro.intro.intro.right
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ X.op
e : X.op ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ i.unop ≫ e.unop = p

tactic: rfl
state_before: case intro.intro.intro.intro.right
C : Type u_1
inst✝ : Category C
h : IsIdempotentComplete Cᵒᵖ
X : C
p : X ⟶ X
hp : p ≫ p = p
Y : Cᵒᵖ
i : Y ⟶ X.op
e : X.op ⟶ Y
h₁ : i ≫ e = 𝟙 Y
h₂ : e ≫ i = p.op
⊢ p.op.unop = p
Theorem: Function.mulSupport_const
File: Mathlib/Algebra/Support.lean

tactic: ext x
state_before: α : Type u_2
β : Type ?u.9120
A : Type ?u.9123
B : Type ?u.9126
M : Type u_1
N : Type ?u.9132
P : Type ?u.9135
R : Type ?u.9138
S : Type ?u.9141
G : Type ?u.9144
M₀ : Type ?u.9147
G₀ : Type ?u.9150
ι : Sort ?u.9153
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
c : M
hc : c ≠ 1
⊢ (mulSupport fun x => c) = univ

tactic: simp [hc]
state_before: case h
α : Type u_2
β : Type ?u.9120
A : Type ?u.9123
B : Type ?u.9126
M : Type u_1
N : Type ?u.9132
P : Type ?u.9135
R : Type ?u.9138
S : Type ?u.9141
G : Type ?u.9144
M₀ : Type ?u.9147
G₀ : Type ?u.9150
ι : Sort ?u.9153
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
c : M
hc : c ≠ 1
x : α
⊢ (x ∈ mulSupport fun x => c) ↔ x ∈ univ
Theorem: Int.mul_add
File: Std/Data/Int/Lemmas.lean

tactic: simp [Nat.left_distrib]
state_before: m n k : Nat
⊢ ↑m * (↑n + ↑k) = ↑m * ↑n + ↑m * ↑k

tactic: simp [negOfNat_eq_subNatNat_zero]
state_before: m n k : Nat
⊢ ↑m * (↑n + -[k+1]) = ↑m * ↑n + ↑m * -[k+1]

tactic: rw [← subNatNat_add]
state_before: m n k : Nat
⊢ subNatNat (m * n) (m * succ k) = ↑(m * n) + subNatNat 0 (m * succ k)

tactic: rfl
state_before: m n k : Nat
⊢ subNatNat (m * n) (m * succ k) = subNatNat (m * n + 0) (m * succ k)

tactic: simp [negOfNat_eq_subNatNat_zero]
state_before: m n k : Nat
⊢ ↑m * (-[n+1] + ↑k) = ↑m * -[n+1] + ↑m * ↑k

tactic: rw [Int.add_comm, ← subNatNat_add]
state_before: m n k : Nat
⊢ subNatNat (m * k) (m * succ n) = subNatNat 0 (m * succ n) + ↑(m * k)

tactic: rfl
state_before: m n k : Nat
⊢ subNatNat (m * k) (m * succ n) = subNatNat (m * k + 0) (m * succ n)

tactic: simp
state_before: m n k : Nat
⊢ ↑m * (-[n+1] + -[k+1]) = ↑m * -[n+1] + ↑m * -[k+1]

tactic: rw [← Nat.left_distrib, succ_add]
state_before: m n k : Nat
⊢ negOfNat (m * succ (succ (n + k))) = negOfNat (m * succ n + m * succ k)

tactic: rfl
state_before: m n k : Nat
⊢ negOfNat (m * succ (succ (n + k))) = negOfNat (m * succ (n + succ k))

tactic: simp [Nat.mul_comm]
state_before: m n k : Nat
⊢ -[m+1] * (↑n + ↑k) = -[m+1] * ↑n + -[m+1] * ↑k

tactic: rw [← Nat.right_distrib, Nat.mul_comm]
state_before: m n k : Nat
⊢ negOfNat ((n + k) * succ m) = negOfNat (n * succ m + k * succ m)

tactic: simp [negOfNat_eq_subNatNat_zero]
state_before: m n k : Nat
⊢ -[m+1] * (↑n + -[k+1]) = -[m+1] * ↑n + -[m+1] * -[k+1]

tactic: rw [Int.add_comm, ← subNatNat_add]
state_before: m n k : Nat
⊢ subNatNat (succ m * succ k) (succ m * n) = subNatNat 0 (succ m * n) + ↑(succ m * succ k)

tactic: rfl
state_before: m n k : Nat
⊢ subNatNat (succ m * succ k) (succ m * n) = subNatNat (succ m * succ k + 0) (succ m * n)

tactic: simp [negOfNat_eq_subNatNat_zero]
state_before: m n k : Nat
⊢ -[m+1] * (-[n+1] + ↑k) = -[m+1] * -[n+1] + -[m+1] * ↑k

tactic: rw [← subNatNat_add]
state_before: m n k : Nat
⊢ subNatNat (succ m * succ n) (succ m * k) = ↑(succ m * succ n) + subNatNat 0 (succ m * k)

tactic: rfl
state_before: m n k : Nat
⊢ subNatNat (succ m * succ n) (succ m * k) = subNatNat (succ m * succ n + 0) (succ m * k)

tactic: simp
state_before: m n k : Nat
⊢ -[m+1] * (-[n+1] + -[k+1]) = -[m+1] * -[n+1] + -[m+1] * -[k+1]

tactic: rw [← Nat.left_distrib, succ_add]
state_before: m n k : Nat
⊢ ↑(succ m * succ (succ (n + k))) = ↑(succ m * succ n + succ m * succ k)

tactic: rfl
state_before: m n k : Nat
⊢ ↑(succ m * succ (succ (n + k))) = ↑(succ m * succ (n + succ k))
Theorem: orderOf_pow'
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: unfold orderOf
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : n ≠ 0
⊢ orderOf (x ^ n) = orderOf x / gcd (orderOf x) n

tactic: rw [← minimalPeriod_iterate_eq_div_gcd h, mul_left_iterate]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : n ≠ 0
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / gcd (minimalPeriod (fun x_1 => x * x_1) 1) n
Theorem: CategoryTheory.Limits.Cones.cone_iso_of_hom_iso
File: Mathlib/CategoryTheory/Limits/Cones.lean

tactic: aesop_cat
state_before: J : Type u₁
inst✝³ : Category J
K✝ : Type u₂
inst✝² : Category K✝
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F K : J ⥤ C
c d : Cone K
f : c ⟶ d
i : IsIso f.Hom
⊢ f ≫ ConeMorphism.mk (inv f.Hom) = 𝟙 c ∧ ConeMorphism.mk (inv f.Hom) ≫ f = 𝟙 d
Theorem: Finset.sigmaLift_nonempty
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp_rw [nonempty_iff_ne_empty, sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ Finset.Nonempty (sigmaLift f a b) ↔ ∃ h, Finset.Nonempty (f (h ▸ a.snd) b.snd)

tactic: split_ifs with h <;> simp [h]
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅) ≠ ∅ ↔
    ∃ h, f ((_ : a.fst = b.fst) ▸ a.snd) b.snd ≠ ∅
Theorem: isGenericPoint_iff_forall_closed
File: Mathlib/Topology/Sober.lean

tactic: have : closure {x} ⊆ S := closure_minimal (singleton_subset_iff.2 hxS) hS
state_before: α : Type u_1
β : Type ?u.3096
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
hS : IsClosed S
hxS : x ∈ S
⊢ IsGenericPoint x S ↔ ∀ (Z : Set α), IsClosed Z → x ∈ Z → S ⊆ Z

tactic: simp_rw [IsGenericPoint, subset_antisymm_iff, this, true_and_iff, closure, subset_sInter_iff,
  mem_setOf_eq, and_imp, singleton_subset_iff]
state_before: α : Type u_1
β : Type ?u.3096
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
hS : IsClosed S
hxS : x ∈ S
this : closure {x} ⊆ S
⊢ IsGenericPoint x S ↔ ∀ (Z : Set α), IsClosed Z → x ∈ Z → S ⊆ Z
Theorem: Order.Icc_pred_left
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [← Ici_inter_Iic, Ici_pred, insert_inter_of_mem (mem_Iic.2 h)]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h : pred a ≤ b
⊢ Icc (pred a) b = insert (pred a) (Icc a b)
Theorem: Metric.uniformEmbedding_bot_of_pairwise_le_dist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: infer_instance
state_before: α : Type u
β✝ : Type v
X : Type ?u.559730
ι : Type ?u.559733
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x : γ
s : Set γ
β : Type ?u.559749
ε : ℝ
hε : 0 < ε
f : β → α
hf : Pairwise fun x y => ε ≤ dist (f x) (f y)
⊢ UniformSpace α

tactic: simpa using hf
state_before: α : Type u
β✝ : Type v
X : Type ?u.559730
ι : Type ?u.559733
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x : γ
s : Set γ
β : Type u_1
ε : ℝ
hε : 0 < ε
f : β → α
hf : Pairwise fun x y => ε ≤ dist (f x) (f y)
⊢ Pairwise fun x y => ¬(f x, f y) ∈ {p | dist p.fst p.snd < ε}
Theorem: range_two_mul_add_one
File: Mathlib/Algebra/Parity.lean

tactic: ext x
state_before: F : Type ?u.76433
α✝ : Type ?u.76436
β : Type ?u.76439
R : Type ?u.76442
inst✝² : Semiring α✝
inst✝¹ : Semiring β
m n : α✝
α : Type u_1
inst✝ : Semiring α
⊢ (Set.range fun x => 2 * x + 1) = {a | Odd a}

tactic: simp [Odd, eq_comm]
state_before: case h
F : Type ?u.76433
α✝ : Type ?u.76436
β : Type ?u.76439
R : Type ?u.76442
inst✝² : Semiring α✝
inst✝¹ : Semiring β
m n : α✝
α : Type u_1
inst✝ : Semiring α
x : α
⊢ (x ∈ Set.range fun x => 2 * x + 1) ↔ x ∈ {a | Odd a}
Theorem: Cycle.Subsingleton.nodup
File: Mathlib/Data/List/Cycle.lean

tactic: induction' s using Quot.inductionOn with l
state_before: α : Type u_1
s : Cycle α
h : Subsingleton s
⊢ Nodup s

tactic: cases' l with hd tl
state_before: case h
α : Type u_1
s : Cycle α
h✝ : Subsingleton s
l : List α
h : Subsingleton (Quot.mk Setoid.r l)
⊢ Nodup (Quot.mk Setoid.r l)

tactic: simp
state_before: case h.nil
α : Type u_1
s : Cycle α
h✝ : Subsingleton s
h : Subsingleton (Quot.mk Setoid.r [])
⊢ Nodup (Quot.mk Setoid.r [])

tactic: have : tl = [] := by simpa [Subsingleton, length_eq_zero, Nat.succ_le_succ_iff] using h
state_before: case h.cons
α : Type u_1
s : Cycle α
h✝ : Subsingleton s
hd : α
tl : List α
h : Subsingleton (Quot.mk Setoid.r (hd :: tl))
⊢ Nodup (Quot.mk Setoid.r (hd :: tl))

tactic: simp [this]
state_before: case h.cons
α : Type u_1
s : Cycle α
h✝ : Subsingleton s
hd : α
tl : List α
h : Subsingleton (Quot.mk Setoid.r (hd :: tl))
this : tl = []
⊢ Nodup (Quot.mk Setoid.r (hd :: tl))

tactic: simpa [Subsingleton, length_eq_zero, Nat.succ_le_succ_iff] using h
state_before: α : Type u_1
s : Cycle α
h✝ : Subsingleton s
hd : α
tl : List α
h : Subsingleton (Quot.mk Setoid.r (hd :: tl))
⊢ tl = []
Theorem: finprod_of_isEmpty
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_one]
state_before: G : Type ?u.32897
M : Type u_2
N : Type ?u.32903
α : Sort u_1
β : Sort ?u.32909
ι : Sort ?u.32912
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : IsEmpty α
f : α → M
⊢ (∏ᶠ (i : α), f i) = 1

tactic: congr
state_before: G : Type ?u.32897
M : Type u_2
N : Type ?u.32903
α : Sort u_1
β : Sort ?u.32909
ι : Sort ?u.32912
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : IsEmpty α
f : α → M
⊢ (∏ᶠ (i : α), f i) = ∏ᶠ (x : ?m.33452), 1

G : Type ?u.32897
M : Type u_2
N : Type ?u.32903
α : Sort u_1
β : Sort ?u.32909
ι : Sort ?u.32912
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : IsEmpty α
f : α → M
⊢ Sort ?u.33450

tactic: simp
state_before: case e_f
G : Type ?u.32897
M : Type u_2
N : Type ?u.32903
α : Sort u_1
β : Sort ?u.32909
ι : Sort ?u.32912
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : IsEmpty α
f : α → M
⊢ (fun i => f i) = fun x => 1
Theorem: Finset.Icc_erase_right
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp [← coe_inj]
state_before: ι : Type ?u.76986
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ erase (Icc a b) b = Ico a b