tasksource/leandojo huggingface dataset:
Theorem: lie_skew
File: Mathlib/Algebra/Lie/Basic.lean

tactic: have h : ⁅x + y, x⁆ + ⁅x + y, y⁆ = 0 := by rw [← lie_add]; apply lie_self
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
t : R
x y z : L
m n : M
⊢ -⁅y, x⁆ = ⁅x, y⁆

tactic: simpa [neg_eq_iff_add_eq_zero] using h
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
t : R
x y z : L
m n : M
h : ⁅x + y, x⁆ + ⁅x + y, y⁆ = 0
⊢ -⁅y, x⁆ = ⁅x, y⁆

tactic: rw [← lie_add]
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
t : R
x y z : L
m n : M
⊢ ⁅x + y, x⁆ + ⁅x + y, y⁆ = 0

tactic: apply lie_self
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
t : R
x y z : L
m n : M
⊢ ⁅x + y, x + y⁆ = 0
Theorem: Infinite.nonempty
File: Mathlib/Data/Fintype/Card.lean

tactic: infer_instance
state_before: α✝ : Type ?u.67178
β : Type ?u.67181
γ : Type ?u.67184
α : Type u_1
inst✝ : Infinite α
⊢ Nonempty α
Theorem: Option.mem_toList
File: Mathlib/Data/Option/Defs.lean

tactic: cases o <;> simp [toList, eq_comm]
state_before: α : Type u_1
β : Type ?u.3576
a : α
o : Option α
⊢ a ∈ toList o ↔ a ∈ o
Theorem: MeasureTheory.Measure.restrict_iUnion_apply_eq_iSup
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [restrict_apply ht, inter_iUnion]
state_before: α : Type u_2
β : Type ?u.304451
γ : Type ?u.304454
δ : Type ?u.304457
ι : Type u_1
R : Type ?u.304463
R' : Type ?u.304466
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) s
t : Set α
ht : MeasurableSet t
⊢ ↑↑(restrict μ (⋃ (i : ι), s i)) t = ⨆ (i : ι), ↑↑(restrict μ (s i)) t

tactic: rw [measure_iUnion_eq_iSup]
state_before: α : Type u_2
β : Type ?u.304451
γ : Type ?u.304454
δ : Type ?u.304457
ι : Type u_1
R : Type ?u.304463
R' : Type ?u.304466
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) s
t : Set α
ht : MeasurableSet t
⊢ ↑↑μ (⋃ (i : ι), t ∩ s i) = ⨆ (i : ι), ↑↑μ (t ∩ s i)

tactic: exacts [hd.mono_comp _ fun s₁ s₂ => inter_subset_inter_right _]
state_before: α : Type u_2
β : Type ?u.304451
γ : Type ?u.304454
δ : Type ?u.304457
ι : Type u_1
R : Type ?u.304463
R' : Type ?u.304466
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Directed (fun x x_1 => x ⊆ x_1) s
t : Set α
ht : MeasurableSet t
⊢ Directed (fun x x_1 => x ⊆ x_1) fun i => t ∩ s i
Theorem: Polynomial.natDegree_C_mul
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: simp only [natDegree, degree_C_mul a0]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a0 : a ≠ 0
⊢ natDegree (↑C a * p) = natDegree p
Theorem: minpoly.zero
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: simpa only [add_zero, C_0, sub_eq_add_neg, neg_zero, RingHom.map_zero] using eq_X_sub_C B (0 : A)
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : Algebra A B
x : B
inst✝ : Nontrivial B
⊢ minpoly A 0 = X
Theorem: Nat.left_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: simpa using unpair_left_le (pair a b)
state_before: a b : ℕ
⊢ a ≤ pair a b
Theorem: symmDiff_symmDiff_self'
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, symmDiff_symmDiff_cancel_left]
state_before: ι : Type ?u.74425
α : Type u_1
β : Type ?u.74431
π : ι → Type ?u.74436
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ b ∆ a = b
Theorem: Nat.bodd_add
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: induction' n with n IH
state_before: m n : ℕ
⊢ bodd (m + n) = bxor (bodd m) (bodd n)

tactic: simp
state_before: case zero
m : ℕ
⊢ bodd (m + zero) = bxor (bodd m) (bodd zero)

tactic: simp [add_succ, IH]
state_before: case succ
m n : ℕ
IH : bodd (m + n) = bxor (bodd m) (bodd n)
⊢ bodd (m + succ n) = bxor (bodd m) (bodd (succ n))

tactic: cases bodd m <;> cases bodd n <;> rfl
state_before: case succ
m n : ℕ
IH : bodd (m + n) = bxor (bodd m) (bodd n)
⊢ (!bxor (bodd m) (bodd n)) = bxor (bodd m) !bodd n
Theorem: FreeMagma.hom_ext
File: Mathlib/Algebra/Free.lean

tactic: intros
state_before: α : Type u
β : Type v
inst✝ : Mul β
f g : FreeMagma α →ₙ* β
h : ↑f ∘ of = ↑g ∘ of
x : FreeMagma α
⊢ ∀ (x y : FreeMagma α), ↑f x = ↑g x → ↑f y = ↑g y → ↑f (x * y) = ↑g (x * y)

tactic: simp only [map_mul, *]
state_before: α : Type u
β : Type v
inst✝ : Mul β
f g : FreeMagma α →ₙ* β
h : ↑f ∘ of = ↑g ∘ of
x x✝ y✝ : FreeMagma α
a✝¹ : ↑f x✝ = ↑g x✝
a✝ : ↑f y✝ = ↑g y✝
⊢ ↑f (x✝ * y✝) = ↑g (x✝ * y✝)
Theorem: NNReal.arith_mean_le_rpow_mean
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: exact_mod_cast
  Real.arith_mean_le_rpow_mean s _ _ (fun i _ => (w i).coe_nonneg) (by exact_mod_cast hw')
    (fun i _ => (z i).coe_nonneg) hp
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i in s, w i * z i ≤ (∑ i in s, w i * z i ^ p) ^ (1 / p)

tactic: exact_mod_cast hw'
state_before: ι : Type u
s : Finset ι
w z : ι → ℝ≥0
hw' : ∑ i in s, w i = 1
p : ℝ
hp : 1 ≤ p
⊢ ∑ i in s, ↑(w i) = 1
Theorem: Int.div_add_mod'
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm]
state_before: m k : Int
⊢ div m k * k + mod m k = m

tactic: apply div_add_mod
state_before: m k : Int
⊢ k * div m k + mod m k = m
Theorem: ModuleCat.mono_iff_injective
File: Mathlib/Algebra/Category/ModuleCat/EpiMono.lean

tactic: rw [mono_iff_ker_eq_bot, LinearMap.ker_eq_bot]
state_before: R : Type u
inst✝² : Ring R
X Y : ModuleCat R
f : X ⟶ Y
M : Type v
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Mono f ↔ Function.Injective ↑f
Theorem: Filter.eventually_or_distrib_right
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [@or_comm _ q, eventually_or_distrib_left]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.144374
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∀ᶠ (x : α) in f, p x ∨ q) ↔ (∀ᶠ (x : α) in f, p x) ∨ q
Theorem: Representation.asModuleEquiv_symm_map_rho
File: Mathlib/RepresentationTheory/Basic.lean

tactic: apply_fun ρ.asModuleEquiv
state_before: k : Type u_2
G : Type u_3
V : Type u_1
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
x : V
⊢ ↑(AddEquiv.symm (asModuleEquiv ρ)) (↑(↑ρ g) x) = ↑(of k G) g • ↑(AddEquiv.symm (asModuleEquiv ρ)) x

tactic: simp
state_before: k : Type u_2
G : Type u_3
V : Type u_1
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
x : V
⊢ ↑(asModuleEquiv ρ) (↑(AddEquiv.symm (asModuleEquiv ρ)) (↑(↑ρ g) x)) =
    ↑(asModuleEquiv ρ) (↑(of k G) g • ↑(AddEquiv.symm (asModuleEquiv ρ)) x)
Theorem: Subgroup.center_le_normalizer
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp [← mem_center_iff.mp hx y, mul_assoc]
state_before: G : Type u_1
G' : Type ?u.384795
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.384804
inst✝ : AddGroup A
H K : Subgroup G
x : G
hx : x ∈ center G
y : G
⊢ y ∈ H ↔ x * y * x⁻¹ ∈ H
Theorem: DiscreteQuotient.ofLE_ofLE
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: rcases x with ⟨⟩
state_before: α : Type ?u.13886
X : Type u_1
Y : Type ?u.13892
Z : Type ?u.13895
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
h₁ : A ≤ B
h₂ : B ≤ C
x : Quotient A.toSetoid
⊢ ofLE h₂ (ofLE h₁ x) = ofLE (_ : A ≤ C) x

tactic: rfl
state_before: case mk
α : Type ?u.13886
X : Type u_1
Y : Type ?u.13892
Z : Type ?u.13895
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
h₁ : A ≤ B
h₂ : B ≤ C
x : Quotient A.toSetoid
a✝ : X
⊢ ofLE h₂ (ofLE h₁ (Quot.mk Setoid.r a✝)) = ofLE (_ : A ≤ C) (Quot.mk Setoid.r a✝)
Theorem: Cardinal.toNat_cast
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [toNat_apply_of_lt_aleph0 (nat_lt_aleph0 n), ← natCast_inj]
state_before: α β : Type u
n : ℕ
⊢ ↑toNat ↑n = n

tactic: exact (Classical.choose_spec (lt_aleph0.1 (nat_lt_aleph0 n))).symm
state_before: α β : Type u
n : ℕ
⊢ ↑(choose (_ : ∃ n_1, ↑n = ↑n_1)) = ↑n
Theorem: mul_sub_one
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [mul_sub, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing α
a b : α
⊢ a * (b - 1) = a * b - a
Theorem: Filter.Tendsto.prod_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← prod_atTop_atTop_eq]
state_before: ι : Type ?u.288498
ι' : Type ?u.288501
α : Type u_1
β : Type ?u.288507
γ : Type u_2
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup γ
f g : α → γ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ Tendsto (Prod.map f g) atTop atTop

tactic: exact hf.prod_map_prod_atTop hg
state_before: ι : Type ?u.288498
ι' : Type ?u.288501
α : Type u_1
β : Type ?u.288507
γ : Type u_2
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup γ
f g : α → γ
hf : Tendsto f atTop atTop
hg : Tendsto g atTop atTop
⊢ Tendsto (Prod.map f g) (atTop ×ˢ atTop) atTop
Theorem: CategoryTheory.Limits.bicone_ι_π_self
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simpa using B.ι_π j j
state_before: J : Type w
C : Type u
inst✝¹ : Category C
inst✝ : HasZeroMorphisms C
F : J → C
B : Bicone F
j : J
⊢ Bicone.ι B j ≫ Bicone.π B j = 𝟙 (F j)
Theorem: List.dropLast_concat
File: Std/Data/List/Lemmas.lean

tactic: simp
state_before: α✝ : Type u_1
l₁ : List α✝
b : α✝
⊢ dropLast (l₁ ++ [b]) = l₁
Theorem: Finset.noncommProd_insert_of_not_mem'
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: convert noncommProd_lemma _ f comm using 3
state_before: F : Type ?u.151034
ι : Type ?u.151037
α : Type u_1
β : Type u_2
γ : Type ?u.151046
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s : Finset α
a : α
f : α → β
comm : Set.Pairwise ↑(insert a s) fun a b => Commute (f a) (f b)
ha : ¬a ∈ s
⊢ Set.Pairwise {x | x ∈ f a ::ₘ Multiset.map f s.val} Commute

tactic: simp [@eq_comm _ (f a)]
state_before: case h.e'_2.h.e'_2.h.a
F : Type ?u.151034
ι : Type ?u.151037
α : Type u_1
β : Type u_2
γ : Type ?u.151046
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s : Finset α
a : α
f : α → β
comm : Set.Pairwise ↑(insert a s) fun a b => Commute (f a) (f b)
ha : ¬a ∈ s
x✝ : β
⊢ x✝ ∈ f a ::ₘ Multiset.map f s.val ↔ x✝ ∈ Multiset.map f (insert a s).val

tactic: rw [Multiset.noncommProd_cons', noncommProd]
state_before: F : Type ?u.151034
ι : Type ?u.151037
α : Type u_1
β : Type u_2
γ : Type ?u.151046
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
s : Finset α
a : α
f : α → β
comm : Set.Pairwise ↑(insert a s) fun a b => Commute (f a) (f b)
ha : ¬a ∈ s
⊢ Multiset.noncommProd (f a ::ₘ Multiset.map f s.val)
      (_ : Set.Pairwise {x | x ∈ f a ::ₘ Multiset.map f s.val} Commute) =
    noncommProd s f (_ : Set.Pairwise ↑s fun a b => Commute (f a) (f b)) * f a
Theorem: FreeGroup.Red.length
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: induction' h with L₂ L₃ _h₁₂ h₂₃ ih
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
h : Red L₁ L₂
⊢ ∃ n, List.length L₁ = List.length L₂ + 2 * n

tactic: exact ⟨0, rfl⟩
state_before: case refl
α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ ∃ n, List.length L₁ = List.length L₁ + 2 * n

tactic: rcases ih with ⟨n, eq⟩
state_before: case tail
α : Type u
L L₁ L₂✝ L₃✝ L₄ L₂ L₃ : List (α × Bool)
_h₁₂ : ReflTransGen Step L₁ L₂
h₂₃ : Step L₂ L₃
ih : ∃ n, List.length L₁ = List.length L₂ + 2 * n
⊢ ∃ n, List.length L₁ = List.length L₃ + 2 * n

tactic: exists 1 + n
state_before: case tail.intro
α : Type u
L L₁ L₂✝ L₃✝ L₄ L₂ L₃ : List (α × Bool)
_h₁₂ : ReflTransGen Step L₁ L₂
h₂₃ : Step L₂ L₃
n : ℕ
eq : List.length L₁ = List.length L₂ + 2 * n
⊢ ∃ n, List.length L₁ = List.length L₃ + 2 * n

tactic: simp [mul_add, eq, (Step.length h₂₃).symm, add_assoc]
state_before: case tail.intro
α : Type u
L L₁ L₂✝ L₃✝ L₄ L₂ L₃ : List (α × Bool)
_h₁₂ : ReflTransGen Step L₁ L₂
h₂₃ : Step L₂ L₃
n : ℕ
eq : List.length L₁ = List.length L₂ + 2 * n
⊢ List.length L₁ = List.length L₃ + 2 * (1 + n)
Theorem: Complex.tan_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: by_cases h : x = 0
state_before: x : ℂ
⊢ Real.tan (arg x) = x.im / x.re

tactic: rw [Real.tan_eq_sin_div_cos, sin_arg, cos_arg h, div_div_div_cancel_right _ (abs.ne_zero h)]
state_before: case neg
x : ℂ
h : ¬x = 0
⊢ Real.tan (arg x) = x.im / x.re

tactic: simp only [h, zero_div, Complex.zero_im, Complex.arg_zero, Real.tan_zero, Complex.zero_re]
state_before: case pos
x : ℂ
h : x = 0
⊢ Real.tan (arg x) = x.im / x.re
Theorem: ContinuousLinearMap.dist_le_op_norm
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simp_rw [dist_eq_norm, ← map_sub, f.le_op_norm]
state_before: 𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type ?u.308122
E : Type u_2
Eₗ : Type ?u.308128
F : Type u_1
Fₗ : Type ?u.308134
G : Type ?u.308137
Gₗ : Type ?u.308140
𝓕 : Type ?u.308143
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : RingHomIsometric σ₁₂
inst✝ : RingHomIsometric σ₂₃
f g : E →SL[σ₁₂] F
h : F →SL[σ₂₃] G
x✝ x y : E
⊢ dist (↑f x) (↑f y) ≤ ‖f‖ * dist x y
Theorem: Cardinal.mk_finsupp_of_infinite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp
state_before: α β : Type u
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ (#α →₀ β) = max (#α) (#β)
Theorem: Real.Angle.cos_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ cos (↑(π / 2) - θ) = sin θ

tactic: exact Real.cos_pi_div_two_sub _
state_before: case h
x✝ : ℝ
⊢ cos (↑(π / 2) - ↑x✝) = sin ↑x✝
Theorem: Int.ModEq.add_left_cancel
File: Mathlib/Data/Int/ModEq.lean

tactic: ring
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
⊢ d - c = b + d - (a + c) - (b - a)

tactic: rw [this]
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
this : d - c = b + d - (a + c) - (b - a)
⊢ n ∣ d - c

tactic: exact dvd_sub h₂.dvd h₁.dvd
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : a + c ≡ b + d [ZMOD n]
this : d - c = b + d - (a + c) - (b - a)
⊢ n ∣ b + d - (a + c) - (b - a)
Theorem: Fin.sign_cycleRange
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: simp [cycleRange]
state_before: n : ℕ
i : Fin n
⊢ ↑sign (cycleRange i) = (-1) ^ ↑i
Theorem: Mathlib.Meta.NormNum.isRat_mkRat
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [Rat.mkRat_eq_div]
state_before: n✝¹ num✝ : ℤ
n✝ denom✝ : ℕ
inv✝ : Invertible ↑denom✝
h : ↑n✝¹ / ↑n✝ = ↑num✝ * ⅟↑denom✝
⊢ IsRat (mkRat ↑n✝¹ ↑n✝) num✝ denom✝

tactic: exact ⟨_, h⟩
state_before: n✝¹ num✝ : ℤ
n✝ denom✝ : ℕ
inv✝ : Invertible ↑denom✝
h : ↑n✝¹ / ↑n✝ = ↑num✝ * ⅟↑denom✝
⊢ IsRat (↑↑n✝¹ / ↑↑n✝) num✝ denom✝
Theorem: dist_edist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [edist_dist, ENNReal.toReal_ofReal dist_nonneg]
state_before: α : Type u
β : Type v
X : Type ?u.24798
ι : Type ?u.24801
inst✝ : PseudoMetricSpace α
x y : α
⊢ dist x y = ENNReal.toReal (edist x y)
Theorem: IsMetricSeparated.disjoint
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

tactic: simpa using hr x hx1 x hx2
state_before: X : Type u_1
inst✝ : EMetricSpace X
s t : Set X
x✝ y : X
h : IsMetricSeparated s t
r : ENNReal
r0 : r ≠ 0
hr : ∀ (x : X), x ∈ s → ∀ (y : X), y ∈ t → r ≤ edist x y
x : X
hx1 : x ∈ s
hx2 : x ∈ t
⊢ r = 0
Theorem: Computation.of_think_mem
File: Mathlib/Data/Seq/Computation.lean

tactic: cases' n with n'
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : (fun b => some a = b) (Stream'.nth (↑(think s)) n)
⊢ a ∈ s

tactic: contradiction
state_before: case zero
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
h : some a = Stream'.nth (↑(think s)) Nat.zero
⊢ a ∈ s

case succ
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n' : ℕ
h : some a = Stream'.nth (↑(think s)) (Nat.succ n')
⊢ a ∈ s

tactic: exact ⟨n', h⟩
state_before: case succ
α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n' : ℕ
h : some a = Stream'.nth (↑(think s)) (Nat.succ n')
⊢ a ∈ s
Theorem: exists_int_gt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rwa [Int.cast_ofNat]
state_before: α : Type u_1
inst✝¹ : StrictOrderedRing α
inst✝ : Archimedean α
x : α
n : ℕ
h : x < ↑n
⊢ x < ↑↑n
Theorem: Ordinal.enumOrd_mem_aux
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [enumOrd_def']
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
o : Ordinal
⊢ enumOrd S o ∈ S ∩ Ici (blsub o fun c x => enumOrd S c)

tactic: exact csInf_mem (enumOrd_def'_nonempty hS _)
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
o : Ordinal
⊢ sInf (S ∩ Ici (blsub o fun a x => enumOrd S a)) ∈ S ∩ Ici (blsub o fun c x => enumOrd S c)
Theorem: Polynomial.map_dvd_map
File: Mathlib/Data/Polynomial/Div.lean

tactic: rw [← dvd_iff_modByMonic_eq_zero hx, ← dvd_iff_modByMonic_eq_zero (hx.map f), ←
  map_modByMonic f hx]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hf : Function.Injective ↑f
x y : R[X]
hx : Monic x
⊢ map f x ∣ map f y ↔ x ∣ y

tactic: exact
  ⟨fun H => map_injective f hf <| by rw [H, Polynomial.map_zero], fun H => by
    rw [H, Polynomial.map_zero]⟩
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hf : Function.Injective ↑f
x y : R[X]
hx : Monic x
⊢ map f (y %ₘ x) = 0 ↔ y %ₘ x = 0

tactic: rw [H, Polynomial.map_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hf : Function.Injective ↑f
x y : R[X]
hx : Monic x
H : map f (y %ₘ x) = 0
⊢ map f (y %ₘ x) = map f 0

tactic: rw [H, Polynomial.map_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p q : R[X]
inst✝ : CommRing S
f : R →+* S
hf : Function.Injective ↑f
x y : R[X]
hx : Monic x
H : y %ₘ x = 0
⊢ map f (y %ₘ x) = 0
Theorem: Convex.lipschitzOnWith_of_nnnorm_hasDerivWithin_le
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simp
state_before: E : Type ?u.273429
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
F : Type ?u.273525
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
𝕜 : Type u_1
G : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f f' : 𝕜 → G
s : Set 𝕜
x✝ y : 𝕜
C : ℝ≥0
hs : Convex ℝ s
hf : ∀ (x : 𝕜), x ∈ s → HasDerivWithinAt f (f' x) s x
bound : ∀ (x : 𝕜), x ∈ s → ‖f' x‖₊ ≤ C
x : 𝕜
hx : x ∈ s
⊢ ‖smulRight 1 (f' x)‖₊ ≤ ‖f' x‖₊
Theorem: MeasureTheory.SignedMeasure.someExistsOneDivLT_subset
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: by_cases hi : ¬s ≤[i] 0
state_before: α : Type u_1
β : Type ?u.6227
inst✝³ : MeasurableSpace α
M : Type ?u.6233
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s i ⊆ i

tactic: exact
  let ⟨h, _⟩ := someExistsOneDivLT_spec hi
  h
state_before: case pos
α : Type u_1
β : Type ?u.6227
inst✝³ : MeasurableSpace α
M : Type ?u.6233
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s i ⊆ i

tactic: rw [someExistsOneDivLT, dif_neg hi]
state_before: case neg
α : Type u_1
β : Type ?u.6227
inst✝³ : MeasurableSpace α
M : Type ?u.6233
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬¬restrict s i ≤ restrict 0 i
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s i ⊆ i

tactic: exact Set.empty_subset _
state_before: case neg
α : Type u_1
β : Type ?u.6227
inst✝³ : MeasurableSpace α
M : Type ?u.6233
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬¬restrict s i ≤ restrict 0 i
⊢ ∅ ⊆ i
Theorem: Int.abs_sign_of_nonzero
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [abs_eq_natAbs, natAbs_sign_of_nonzero hz, Int.ofNat_one]
state_before: a b : ℤ
n : ℕ
z : ℤ
hz : z ≠ 0
⊢ abs (sign z) = 1
Theorem: List.Pairwise.drop
File: Mathlib/Data/List/Pairwise.lean

tactic: rw [List.drop]
state_before: α : Type u_1
β : Type ?u.876
R S T : α → α → Prop
a✝ : α
l✝ : List α
a : α
l : List α
n : ℕ
h : Pairwise R (a :: l)
⊢ Pairwise R (List.drop (n + 1) (a :: l))

tactic: exact Pairwise.drop (pairwise_cons.mp h).right
state_before: α : Type u_1
β : Type ?u.876
R S T : α → α → Prop
a✝ : α
l✝ : List α
a : α
l : List α
n : ℕ
h : Pairwise R (a :: l)
⊢ Pairwise R (List.drop n l)
Theorem: Equiv.Perm.cycleType_conj
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: induction σ using cycle_induction_on with
| base_one => simp
| base_cycles σ hσ => rw [hσ.cycleType, hσ.conj.cycleType, card_support_conj]
| induction_disjoint σ π hd _ hσ hπ =>
  rw [← conj_mul, hd.cycleType, (hd.conj _).cycleType, hσ, hπ]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ τ : Perm α
⊢ cycleType (τ * σ * τ⁻¹) = cycleType σ

tactic: simp
state_before: case base_one
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
τ : Perm α
⊢ cycleType (τ * 1 * τ⁻¹) = cycleType 1

tactic: rw [hσ.cycleType, hσ.conj.cycleType, card_support_conj]
state_before: case base_cycles
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
τ σ : Perm α
hσ : IsCycle σ
⊢ cycleType (τ * σ * τ⁻¹) = cycleType σ

tactic: rw [← conj_mul, hd.cycleType, (hd.conj _).cycleType, hσ, hπ]
state_before: case induction_disjoint
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
τ σ π : Perm α
hd : Disjoint σ π
a✝ : IsCycle σ
hσ : cycleType (τ * σ * τ⁻¹) = cycleType σ
hπ : cycleType (τ * π * τ⁻¹) = cycleType π
⊢ cycleType (τ * (σ * π) * τ⁻¹) = cycleType (σ * π)
Theorem: finset_disjoint_finset_opens_of_t2
File: Mathlib/Topology/Separation.lean

tactic: exact_mod_cast h
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.128695
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
s t : Finset α
h : Disjoint s t
⊢ Disjoint ↑s ↑t
Theorem: Complex.I_mul_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: z : ℂ
⊢ (I * z).re = -z.im
Theorem: Function.Periodic.add_period
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all [← add_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.73852
f g : α → β
c c₁ c₂ x : α
inst✝ : AddSemigroup α
h1 : Periodic f c₁
h2 : Periodic f c₂
⊢ Periodic f (c₁ + c₂)