tasksource/leandojo huggingface dataset:
Theorem: Infinite.natEmbeddingAux_injective
File: Mathlib/Data/Fintype/Card.lean

tactic: rintro m n h
state_before: α✝ : Type ?u.80507
β : Type ?u.80510
γ : Type ?u.80513
α : Type u_1
inst✝ : Infinite α
⊢ Injective (Infinite.natEmbeddingAux α)

tactic: letI := Classical.decEq α
state_before: α✝ : Type ?u.80507
β : Type ?u.80510
γ : Type ?u.80513
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
⊢ m = n

tactic: rcases lt_trichotomy m n with hmn | rfl | hnm
state_before: α✝ : Type ?u.80507
β : Type ?u.80510
γ : Type ?u.80513
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
this : DecidableEq α := Classical.decEq α
⊢ m = n

tactic: apply natEmbeddingAux_injective_aux α m n h hmn
state_before: case inl
α✝ : Type ?u.80507
β : Type ?u.80510
γ : Type ?u.80513
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
this : DecidableEq α := Classical.decEq α
hmn : m < n
⊢ m = n

tactic: rfl
state_before: case inr.inl
α✝ : Type ?u.80507
β : Type ?u.80510
γ : Type ?u.80513
α : Type u_1
inst✝ : Infinite α
m : ℕ
this : DecidableEq α := Classical.decEq α
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α m
⊢ m = m

tactic: apply (natEmbeddingAux_injective_aux α n m h.symm hnm).symm
state_before: case inr.inr
α✝ : Type ?u.80507
β : Type ?u.80510
γ : Type ?u.80513
α : Type u_1
inst✝ : Infinite α
m n : ℕ
h : Infinite.natEmbeddingAux α m = Infinite.natEmbeddingAux α n
this : DecidableEq α := Classical.decEq α
hnm : n < m
⊢ m = n
Theorem: frontier_sphere'
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [isClosed_sphere.frontier_eq, interior_sphere' x, diff_empty]
state_before: α : Type ?u.310915
β : Type ?u.310918
γ : Type ?u.310921
ι : Type ?u.310924
inst✝⁶ : NormedField α
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace α E
F : Type ?u.311017
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace α F
inst✝¹ : NormedSpace ℝ E
inst✝ : Nontrivial E
x : E
r : ℝ
⊢ frontier (sphere x r) = sphere x r
Theorem: CategoryTheory.Bifunctor.map_comp_id
File: Mathlib/CategoryTheory/Products/Bifunctor.lean

tactic: rw [← Functor.map_comp, prod_comp, Category.comp_id]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category C
inst✝¹ : Category D
inst✝ : Category E
F : C × D ⥤ E
X Y Z : C
W : D
f : X ⟶ Y
g : Y ⟶ Z
⊢ F.map (f ≫ g, 𝟙 W) = F.map (f, 𝟙 W) ≫ F.map (g, 𝟙 W)
Theorem: Subalgebra.mul_toSubmodule_le
File: Mathlib/Algebra/Algebra/Subalgebra/Pointwise.lean

tactic: rw [Submodule.mul_le]
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
⊢ ↑toSubmodule S * ↑toSubmodule T ≤ ↑toSubmodule (S ⊔ T)

tactic: intro y hy z hz
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
⊢ ∀ (m : A), m ∈ ↑toSubmodule S → ∀ (n : A), n ∈ ↑toSubmodule T → m * n ∈ ↑toSubmodule (S ⊔ T)

tactic: show y * z ∈ S ⊔ T
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
y : A
hy : y ∈ ↑toSubmodule S
z : A
hz : z ∈ ↑toSubmodule T
⊢ y * z ∈ ↑toSubmodule (S ⊔ T)

tactic: exact mul_mem (Algebra.mem_sup_left hy) (Algebra.mem_sup_right hz)
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
y : A
hy : y ∈ ↑toSubmodule S
z : A
hz : z ∈ ↑toSubmodule T
⊢ y * z ∈ S ⊔ T
Theorem: Nat.log_eq_of_pow_le_of_lt_pow
File: Mathlib/Data/Nat/Log.lean

tactic: rcases eq_or_ne m 0 with (rfl | hm)
state_before: b m n : ℕ
h₁ : b ^ m ≤ n
h₂ : n < b ^ (m + 1)
⊢ log b n = m

tactic: rw [pow_one] at h₂
state_before: case inl
b n : ℕ
h₁ : b ^ 0 ≤ n
h₂ : n < b ^ (0 + 1)
⊢ log b n = 0

tactic: exact log_of_lt h₂
state_before: case inl
b n : ℕ
h₁ : b ^ 0 ≤ n
h₂ : n < b
⊢ log b n = 0

tactic: exact (log_eq_iff (Or.inl hm)).2 ⟨h₁, h₂⟩
state_before: case inr
b m n : ℕ
h₁ : b ^ m ≤ n
h₂ : n < b ^ (m + 1)
hm : m ≠ 0
⊢ log b n = m
Theorem: Multiset.disjoint_iff_ne
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [disjoint_left, imp_not_comm]
state_before: α : Type u_1
β : Type ?u.480530
γ : Type ?u.480533
s t : Multiset α
⊢ Disjoint s t ↔ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ t → a ≠ b
Theorem: CategoryTheory.Limits.pullbackSymmetry_inv_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [Iso.inv_comp_eq]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : HasPullback f g
⊢ (pullbackSymmetry f g).inv ≫ pullback.snd = pullback.fst
Theorem: Dfinsupp.support_eq_empty
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simpa [Finset.ext_iff] using H
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
H : support f = ∅
⊢ ∀ (i : ι), ↑f i = ↑0 i

tactic: simp (config := { contextual := true })
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
⊢ f = 0 → support f = ∅
Theorem: Ordinal.nfpBFamily_le_apply
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← not_iff_not]
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
⊢ (∃ i hi, nfpBFamily o f a ≤ f i hi b) ↔ nfpBFamily o f a ≤ b

tactic: push_neg
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
⊢ (¬∃ i hi, nfpBFamily o f a ≤ f i hi b) ↔ ¬nfpBFamily o f a ≤ b

tactic: exact apply_lt_nfpBFamily_iff.{u, v} ho H
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
⊢ (∀ (i : Ordinal) (hi : i < o), f i hi b < nfpBFamily o f a) ↔ b < nfpBFamily o f a
Theorem: Fin.cases_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n <;> rfl
state_before: n✝ m n : ℕ
C : Fin (n + 1) → Sort u_1
H0 : C 0
Hs : (i : Fin n) → C (succ i)
⊢ cases H0 Hs 0 = H0
Theorem: HasStrictDerivAt.iterate
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: have := hf.iterate hx n
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.192344
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
f : 𝕜 → 𝕜
f' : 𝕜
hf : HasStrictDerivAt f f' x
hx : f x = x
n : ℕ
⊢ HasStrictDerivAt (f^[n]) (f' ^ n) x

tactic: rwa [ContinuousLinearMap.smulRight_one_pow] at this
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.192344
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
f : 𝕜 → 𝕜
f' : 𝕜
hf : HasStrictDerivAt f f' x
hx : f x = x
n : ℕ
this : HasStrictFDerivAt (f^[n]) (smulRight 1 f' ^ n) x
⊢ HasStrictDerivAt (f^[n]) (f' ^ n) x
Theorem: SeparationQuotient.comap_mk_nhdsSet
File: Mathlib/Topology/Inseparable.lean

tactic: conv_lhs => rw [← image_preimage_eq t surjective_mk, comap_mk_nhdsSet_image]
state_before: X : Type u_1
Y : Type ?u.79044
Z : Type ?u.79047
α : Type ?u.79050
ι : Type ?u.79053
π : ι → Type ?u.79058
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
t : Set (SeparationQuotient X)
⊢ comap mk (𝓝ˢ t) = 𝓝ˢ (mk ⁻¹' t)
Theorem: Nat.div_eq_sub_mod_div
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: by_cases n0 : n = 0
state_before: m n k l : ℕ
⊢ m / n = (m - m % n) / n

tactic: rw [n0, Nat.div_zero, Nat.div_zero]
state_before: case pos
m n k l : ℕ
n0 : n = 0
⊢ m / n = (m - m % n) / n

tactic: have : m - m % n = n * (m / n) := by
  rw [tsub_eq_iff_eq_add_of_le (Nat.mod_le _ _), add_comm, mod_add_div]
state_before: case neg
m n k l : ℕ
n0 : ¬n = 0
⊢ m / n = (m - m % n) / n

tactic: rw [this, mul_div_right _ (Nat.pos_of_ne_zero n0)]
state_before: case neg
m n k l : ℕ
n0 : ¬n = 0
this : m - m % n = n * (m / n)
⊢ m / n = (m - m % n) / n

tactic: rw [tsub_eq_iff_eq_add_of_le (Nat.mod_le _ _), add_comm, mod_add_div]
state_before: m n k l : ℕ
n0 : ¬n = 0
⊢ m - m % n = n * (m / n)
Theorem: Int.coe_nat_dvd_right
File: Mathlib/Data/Int/Dvd/Basic.lean

tactic: rcases natAbs_eq z with (eq | eq) <;> rw [eq] <;> simp [←coe_nat_dvd]
state_before: n : ℕ
z : ℤ
⊢ z ∣ ↑n ↔ natAbs z ∣ n
Theorem: nilpotencyClass_prod
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: refine' eq_of_forall_ge_iff fun k => _
state_before: G : Type ?u.332663
inst✝⁵ : Group G
H : Subgroup G
inst✝⁴ : Normal H
G₁ : Type u_1
G₂ : Type u_2
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : Group.IsNilpotent G₁
inst✝ : Group.IsNilpotent G₂
⊢ nilpotencyClass (G₁ × G₂) = max (nilpotencyClass G₁) (nilpotencyClass G₂)

tactic: simp only [max_le_iff, ← lowerCentralSeries_eq_bot_iff_nilpotencyClass_le,
  lowerCentralSeries_prod, prod_eq_bot_iff]
state_before: G : Type ?u.332663
inst✝⁵ : Group G
H : Subgroup G
inst✝⁴ : Normal H
G₁ : Type u_1
G₂ : Type u_2
inst✝³ : Group G₁
inst✝² : Group G₂
inst✝¹ : Group.IsNilpotent G₁
inst✝ : Group.IsNilpotent G₂
k : ℕ
⊢ nilpotencyClass (G₁ × G₂) ≤ k ↔ max (nilpotencyClass G₁) (nilpotencyClass G₂) ≤ k
Theorem: Cardinal.sum_nat_eq_add_sum_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: refine' (Equiv.sigmaNatSucc fun i => Quotient.out (f i)).cardinal_eq.trans _
state_before: α β : Type u
f : ℕ → Cardinal
⊢ sum f = f 0 + sum fun i => f (i + 1)

tactic: simp only [mk_sum, mk_out, lift_id, mk_sigma]
state_before: α β : Type u
f : ℕ → Cardinal
⊢ (#Quotient.out (f 0) ⊕ (n : ℕ) × Quotient.out (f (n + 1))) = f 0 + sum fun i => f (i + 1)
Theorem: Finset.card_div_mul_le_card_mul_mul_card_div
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A / C) * card B ≤ card (A * B) * card (B / C)

tactic: exact card_mul_mul_card_le_card_mul_mul_card_mul _ _ _
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A * C⁻¹) * card B ≤ card (A * B) * card (B * C⁻¹)
Theorem: MeasureTheory.ae_le_set
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp [ae_iff]
state_before: α : Type u_1
β : Type ?u.101868
γ : Type ?u.101871
δ : Type ?u.101874
ι : Type ?u.101877
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ (∀ᵐ (x : α) ∂μ, x ∈ s → x ∈ t) ↔ ↑↑μ (s \ t) = 0

tactic: rfl
state_before: α : Type u_1
β : Type ?u.101868
γ : Type ?u.101871
δ : Type ?u.101874
ι : Type ?u.101877
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ ↑↑μ {a | a ∈ s ∧ ¬a ∈ t} = 0 ↔ ↑↑μ (s \ t) = 0
Theorem: intervalIntegral.integral_smul
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral, integral_smul, smul_sub]
state_before: ι : Type ?u.12999603
𝕜✝ : Type ?u.12999606
E : Type u_2
F : Type ?u.12999612
A : Type ?u.12999615
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass ℝ 𝕜 E
r : 𝕜
f : ℝ → E
⊢ (∫ (x : ℝ) in a..b, r • f x ∂μ) = r • ∫ (x : ℝ) in a..b, f x ∂μ
Theorem: is_semisimple_iff_top_eq_sSup_simples
File: Mathlib/RingTheory/SimpleModule.lean

tactic: intro
state_before: R : Type u_2
inst✝⁴ : Ring R
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.47667
inst✝¹ : AddCommGroup N
inst✝ : Module R N
⊢ IsSemisimpleModule R M → sSup {m | IsSimpleModule R { x // x ∈ m }} = ⊤

tactic: exact IsSemisimpleModule.sSup_simples_eq_top
state_before: R : Type u_2
inst✝⁴ : Ring R
M : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.47667
inst✝¹ : AddCommGroup N
inst✝ : Module R N
a✝ : IsSemisimpleModule R M
⊢ sSup {m | IsSimpleModule R { x // x ∈ m }} = ⊤
Theorem: Filter.hasBasis_generate
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [mem_generate_iff, exists_prop, and_assoc, and_left_comm]
state_before: α : Type u_1
β : Type ?u.9944
γ : Type ?u.9947
ι : Sort ?u.9950
ι' : Sort ?u.9953
l l' : Filter α
p : ι → Prop
s✝ : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
s : Set (Set α)
U : Set α
⊢ U ∈ generate s ↔ ∃ i, (Set.Finite i ∧ i ⊆ s) ∧ ⋂₀ i ⊆ U
Theorem: SimplexCategory.eq_δ_of_mono
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: rcases eq_comp_δ_of_not_surjective θ (by
  by_contra h
  simpa using le_of_epi (epi_iff_surjective.mpr h)) with ⟨i, θ', h⟩
state_before: n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
⊢ ∃ i, θ = δ i

tactic: use i
state_before: case intro.intro
n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
i : Fin (n + 2)
θ' : [n] ⟶ [n]
h : θ = θ' ≫ δ i
⊢ ∃ i, θ = δ i

tactic: haveI : Mono (θ' ≫ δ i) := by
  rw [← h]
  infer_instance
state_before: case intro.intro
n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
i : Fin (n + 2)
θ' : [n] ⟶ [n]
h : θ = θ' ≫ δ i
⊢ θ = δ i

tactic: haveI := CategoryTheory.mono_of_mono θ' (δ i)
state_before: case intro.intro
n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
i : Fin (n + 2)
θ' : [n] ⟶ [n]
h : θ = θ' ≫ δ i
this : Mono (θ' ≫ δ i)
⊢ θ = δ i

tactic: rw [h, eq_id_of_mono θ', Category.id_comp]
state_before: case intro.intro
n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
i : Fin (n + 2)
θ' : [n] ⟶ [n]
h : θ = θ' ≫ δ i
this✝ : Mono (θ' ≫ δ i)
this : Mono θ'
⊢ θ = δ i

tactic: by_contra h
state_before: n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
⊢ ¬Function.Surjective ↑(Hom.toOrderHom θ)

tactic: simpa using le_of_epi (epi_iff_surjective.mpr h)
state_before: n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
h : Function.Surjective ↑(Hom.toOrderHom θ)
⊢ False

tactic: rw [← h]
state_before: n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
i : Fin (n + 2)
θ' : [n] ⟶ [n]
h : θ = θ' ≫ δ i
⊢ Mono (θ' ≫ δ i)

tactic: infer_instance
state_before: n : ℕ
θ : [n] ⟶ [n + 1]
inst✝ : Mono θ
i : Fin (n + 2)
θ' : [n] ⟶ [n]
h : θ = θ' ≫ δ i
⊢ Mono θ
Theorem: LocalizedModule.induction_on₂
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rintro ⟨⟨m, s⟩⟩ ⟨⟨m', s'⟩⟩
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : { x // x ∈ S }), β (mk m s) (mk m' s')
⊢ ∀ (x y : LocalizedModule S M), β x y

tactic: exact h m m' s s'
state_before: case mk.mk.mk.mk
R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : { x // x ∈ S }), β (mk m s) (mk m' s')
x✝ : LocalizedModule S M
m : M
s : { x // x ∈ S }
y✝ : LocalizedModule S M
m' : M
s' : { x // x ∈ S }
⊢ β (Quot.mk Setoid.r (m, s)) (Quot.mk Setoid.r (m', s'))
Theorem: Finset.prod_Ioc_consecutive
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [← Ioc_union_Ioc_eq_Ioc hmn hnk, prod_union]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ (∏ i in Ioc m n, f i) * ∏ i in Ioc n k, f i = ∏ i in Ioc m k, f i

tactic: apply disjoint_left.2 fun x hx h'x => _
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ Disjoint (Ioc m n) (Ioc n k)

tactic: intros x hx h'x
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
⊢ ∀ (x : ℕ), x ∈ Ioc m n → x ∈ Ioc n k → False

tactic: exact lt_irrefl _ ((mem_Ioc.1 h'x).1.trans_le (mem_Ioc.1 hx).2)
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝ : CommMonoid β
f : ℕ → β
m n k : ℕ
hmn : m ≤ n
hnk : n ≤ k
x : ℕ
hx : x ∈ Ioc m n
h'x : x ∈ Ioc n k
⊢ False
Theorem: AffineMap.lineMap_apply_zero
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: letI : AddAction V1 P1 := inferInstance
state_before: k : Type u_2
V1 : Type u_3
P1 : Type u_1
V2 : Type ?u.445314
P2 : Type ?u.445317
V3 : Type ?u.445320
P3 : Type ?u.445323
V4 : Type ?u.445326
P4 : Type ?u.445329
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : P1
⊢ ↑(lineMap p₀ p₁) 0 = p₀

tactic: simp [(lineMap_apply)]
state_before: k : Type u_2
V1 : Type u_3
P1 : Type u_1
V2 : Type ?u.445314
P2 : Type ?u.445317
V3 : Type ?u.445320
P3 : Type ?u.445323
V4 : Type ?u.445326
P4 : Type ?u.445329
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : P1
this : AddAction V1 P1 := inferInstance
⊢ ↑(lineMap p₀ p₁) 0 = p₀
Theorem: Stream'.WSeq.map_ret
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [ret]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
⊢ map f (ret a) = ret (f a)
Theorem: CategoryTheory.Limits.IsZero.of_epi_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Epi 0
⊢ 0 ≫ 𝟙 Y = 0 ≫ 0
Theorem: inv_lt_iff_one_lt_mul
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_self]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a⁻¹ * a < b * a ↔ 1 < b * a
Theorem: BoundedOrderHom.cancel_left
File: Mathlib/Order/Hom/Bounded.lean

tactic: rw [← BoundedOrderHom.comp_apply, h, BoundedOrderHom.comp_apply]
state_before: F : Type ?u.76609
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.76621
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : BoundedOrder α
inst✝² : BoundedOrder β
inst✝¹ : BoundedOrder γ
inst✝ : BoundedOrder δ
g : BoundedOrderHom β γ
f₁ f₂ : BoundedOrderHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Substring.Valid.valid
File: Std/Data/String/Lemmas.lean

tactic: simp
state_before: l m r : List Char
⊢ l ++ (m ++ r) =
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.startPos.byteIdx =
      utf8Len l

tactic: simp
state_before: l m r : List Char
⊢ l ++ m ++ r =
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.str.data ∧
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len m } }.stopPos.byteIdx =
      utf8Len (l ++ m)
Theorem: Real.logb_prod
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: induction' s using Finset.induction_on with a s ha ih
state_before: b x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ (x : α), x ∈ s → f x ≠ 0
⊢ logb b (∏ i in s, f i) = ∑ i in s, logb b (f i)

tactic: simp only [Finset.mem_insert, forall_eq_or_imp] at hf
state_before: case insert
b x y : ℝ
α : Type u_1
s✝ : Finset α
f : α → ℝ
hf✝ : ∀ (x : α), x ∈ s✝ → f x ≠ 0
a : α
s : Finset α
ha : ¬a ∈ s
ih : (∀ (x : α), x ∈ s → f x ≠ 0) → logb b (∏ i in s, f i) = ∑ i in s, logb b (f i)
hf : ∀ (x : α), x ∈ insert a s → f x ≠ 0
⊢ logb b (∏ i in insert a s, f i) = ∑ i in insert a s, logb b (f i)

tactic: simp [ha, ih hf.2, logb_mul hf.1 (Finset.prod_ne_zero_iff.2 hf.2)]
state_before: case insert
b x y : ℝ
α : Type u_1
s✝ : Finset α
f : α → ℝ
hf✝ : ∀ (x : α), x ∈ s✝ → f x ≠ 0
a : α
s : Finset α
ha : ¬a ∈ s
ih : (∀ (x : α), x ∈ s → f x ≠ 0) → logb b (∏ i in s, f i) = ∑ i in s, logb b (f i)
hf : f a ≠ 0 ∧ ∀ (a : α), a ∈ s → f a ≠ 0
⊢ logb b (∏ i in insert a s, f i) = ∑ i in insert a s, logb b (f i)

tactic: simp
state_before: case empty
b x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf✝ : ∀ (x : α), x ∈ s → f x ≠ 0
hf : ∀ (x : α), x ∈ ∅ → f x ≠ 0
⊢ logb b (∏ i in ∅, f i) = ∑ i in ∅, logb b (f i)
Theorem: Int.odd_mul
File: Mathlib/Data/Int/Parity.lean

tactic: simp [not_or, parity_simps]
state_before: m n : ℤ
⊢ Odd (m * n) ↔ Odd m ∧ Odd n
Theorem: LowerSet.coe_iInf
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [iInf, coe_sInf, mem_range, iInter_exists, iInter_iInter_eq']
state_before: α : Type u_1
β : Type ?u.71521
γ : Type ?u.71524
ι : Sort u_2
κ : ι → Sort ?u.71532
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ ↑(⨅ (i : ι), f i) = ⋂ (i : ι), ↑(f i)
Theorem: Nat.div.inductionOn
File: src/lean/Init/Data/Nat/Div.lean

tactic: apply div_rec_lemma
state_before: motive : Nat → Nat → Sort u
x y : Nat
ind : (x y : Nat) → 0 < y ∧ y ≤ x → motive (x - y) y → motive x y
base : (x y : Nat) → ¬(0 < y ∧ y ≤ x) → motive x y
h : 0 < y ∧ y ≤ x
⊢ (invImage
        (fun a =>
          PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => PSigma.casesOn snd fun ind snd => sizeOf x)
        instWellFoundedRelation).1
    { fst := x - y, snd := { fst := y, snd := { fst := ind, snd := base } } }
    { fst := x, snd := { fst := y, snd := { fst := ind, snd := base } } }

tactic: assumption
state_before: case a
motive : Nat → Nat → Sort u
x y : Nat
ind : (x y : Nat) → 0 < y ∧ y ≤ x → motive (x - y) y → motive x y
base : (x y : Nat) → ¬(0 < y ∧ y ≤ x) → motive x y
h : 0 < y ∧ y ≤ x
⊢ 0 < y ∧ y ≤ x
Theorem: Turing.PartrecToTM2.contSupp_fix
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp (config := { contextual := true }) [codeSupp, codeSupp', contSupp, Finset.union_assoc,
  Finset.subset_iff]
state_before: f : Code
k : Cont'
⊢ contSupp (Cont'.fix f k) = codeSupp f (Cont'.fix f k)
Theorem: ZMod.nat_cast_eq_nat_cast_iff
File: Mathlib/Data/ZMod/Basic.lean

tactic: simpa [Int.coe_nat_modEq_iff] using ZMod.int_cast_eq_int_cast_iff a b c
state_before: a b c : ℕ
⊢ ↑a = ↑b ↔ a ≡ b [MOD c]
Theorem: Fin.succ_succAbove_one
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← succ_zero_eq_one]
state_before: n✝ m n : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
⊢ ↑(succAbove (succ i)) 1 = succ (↑(succAbove i) 0)

tactic: exact succ_succAbove_succ i 0
state_before: n✝ m n : ℕ
inst✝ : NeZero n
i : Fin (n + 1)
⊢ ↑(succAbove (succ i)) (succ 0) = succ (↑(succAbove i) 0)
Theorem: Int.add_one_ediv_two_mul_two_of_odd
File: Mathlib/Data/Int/Parity.lean

tactic: rintro ⟨c, rfl⟩
state_before: m n : ℤ
⊢ Odd n → 1 + n / 2 * 2 = n

tactic: rw [add_comm]
state_before: case intro
m c : ℤ
⊢ 1 + (2 * c + 1) / 2 * 2 = 2 * c + 1

tactic: convert Int.ediv_add_emod' (2 * c + 1) 2
state_before: case intro
m c : ℤ
⊢ (2 * c + 1) / 2 * 2 + 1 = 2 * c + 1

tactic: simp [Int.add_emod]
state_before: case h.e'_2.h.e'_6
m c : ℤ
⊢ 1 = (2 * c + 1) % 2