tasksource/leandojo huggingface dataset:
Theorem: Int.ediv_dvd_ediv
File: Mathlib/Data/Int/Order/Basic.lean

tactic: simp [az]
state_before: a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
az : a = 0
⊢ a * b / a ∣ a * b * c / a

tactic: rw [Int.mul_ediv_cancel_left _ az, mul_assoc, Int.mul_ediv_cancel_left _ az]
state_before: a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
az : ¬a = 0
⊢ a * b / a ∣ a * b * c / a

tactic: apply dvd_mul_right
state_before: a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
az : ¬a = 0
⊢ b ∣ b * c
Theorem: Group.mem_conjugatesOfSet_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: erw [Set.mem_iUnion₂]
state_before: G : Type u_1
G' : Type ?u.433885
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.433894
inst✝ : AddGroup A
s : Set G
x : G
⊢ x ∈ conjugatesOfSet s ↔ ∃ a, a ∈ s ∧ IsConj a x

tactic: simp only [conjugatesOf, isConj_iff, Set.mem_setOf_eq, exists_prop]
state_before: G : Type u_1
G' : Type ?u.433885
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.433894
inst✝ : AddGroup A
s : Set G
x : G
⊢ (∃ i j, x ∈ conjugatesOf i) ↔ ∃ a, a ∈ s ∧ IsConj a x
Theorem: Homeomorph.map_nhds_eq
File: Mathlib/Topology/Homeomorph.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68402
δ : Type ?u.68405
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
x : α
⊢ range ↑h ∈ 𝓝 (↑h x)
Theorem: div_le_div_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_eq_mul_one_div a c, div_eq_mul_one_div b c]
state_before: ι : Type ?u.61284
α : Type u_1
β : Type ?u.61290
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
h : a ≤ b
⊢ a / c ≤ b / c

tactic: exact mul_le_mul_of_nonneg_right h (one_div_nonneg.2 hc)
state_before: ι : Type ?u.61284
α : Type u_1
β : Type ?u.61290
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
h : a ≤ b
⊢ a * (1 / c) ≤ b * (1 / c)
Theorem: Basis.map_orientation_eq_det_inv_smul
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u_2
inst✝⁵ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.45806
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
x : Orientation R M ι
f : M ≃ₗ[R] M
⊢ ↑(Orientation.map ι f) x = (↑LinearEquiv.det f)⁻¹ • x

tactic: letI := Classical.decEq ι
state_before: case intro
R : Type u_2
inst✝⁵ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.45806
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
x : Orientation R M ι
f : M ≃ₗ[R] M
val✝ : Fintype ι
⊢ ↑(Orientation.map ι f) x = (↑LinearEquiv.det f)⁻¹ • x

tactic: induction' x using Module.Ray.ind with g hg
state_before: case intro
R : Type u_2
inst✝⁵ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.45806
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
x : Orientation R M ι
f : M ≃ₗ[R] M
val✝ : Fintype ι
this : DecidableEq ι := Classical.decEq ι
⊢ ↑(Orientation.map ι f) x = (↑LinearEquiv.det f)⁻¹ • x

tactic: rw [Orientation.map_apply, smul_rayOfNeZero, ray_eq_iff, Units.smul_def,
  (g.compLinearMap f.symm).eq_smul_basis_det e, g.eq_smul_basis_det e,
  AlternatingMap.compLinearMap_apply, AlternatingMap.smul_apply,
  show (fun i ↦ (LinearEquiv.symm f).toLinearMap (e i)) = (LinearEquiv.symm f).toLinearMap ∘ e
  by rfl, Basis.det_comp, Basis.det_self, mul_one, smul_eq_mul, mul_comm, mul_smul,
  LinearEquiv.coe_inv_det]
state_before: case intro.h
R : Type u_2
inst✝⁵ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.45806
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
f : M ≃ₗ[R] M
val✝ : Fintype ι
this : DecidableEq ι := Classical.decEq ι
g : AlternatingMap R M R ι
hg : g ≠ 0
⊢ ↑(Orientation.map ι f) (rayOfNeZero R g hg) = (↑LinearEquiv.det f)⁻¹ • rayOfNeZero R g hg

tactic: rfl
state_before: R : Type u_2
inst✝⁵ : StrictOrderedCommRing R
M : Type u_3
N : Type ?u.45806
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
ι : Type u_1
inst✝ : Finite ι
e : Basis ι R M
f : M ≃ₗ[R] M
val✝ : Fintype ι
this : DecidableEq ι := Classical.decEq ι
g : AlternatingMap R M R ι
hg : g ≠ 0
⊢ (fun i => ↑↑(LinearEquiv.symm f) (↑e i)) = ↑↑(LinearEquiv.symm f) ∘ ↑e
Theorem: MvPolynomial.coeff_rename_eq_zero
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: classical
rw [rename_eq, ← not_mem_support_iff]
intro H
replace H := mapDomain_support H
rw [Finset.mem_image] at H
obtain ⟨u, hu, rfl⟩ := H
specialize h u rfl
simp at h hu
contradiction
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
⊢ coeff d (↑(rename f) φ) = 0

tactic: rw [rename_eq, ← not_mem_support_iff]
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
⊢ coeff d (↑(rename f) φ) = 0

tactic: intro H
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
⊢ ¬d ∈ support (Finsupp.mapDomain (Finsupp.mapDomain f) φ)

tactic: replace H := mapDomain_support H
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
H : d ∈ support (Finsupp.mapDomain (Finsupp.mapDomain f) φ)
⊢ False

tactic: rw [Finset.mem_image] at H
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
H : d ∈ Finset.image (Finsupp.mapDomain f) φ.support
⊢ False

tactic: obtain ⟨u, hu, rfl⟩ := H
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
d : τ →₀ ℕ
h : ∀ (u : σ →₀ ℕ), Finsupp.mapDomain f u = d → coeff u φ = 0
H : ∃ a, a ∈ φ.support ∧ Finsupp.mapDomain f a = d
⊢ False

tactic: specialize h u rfl
state_before: case intro.intro
σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
u : σ →₀ ℕ
hu : u ∈ φ.support
h : ∀ (u_1 : σ →₀ ℕ), Finsupp.mapDomain f u_1 = Finsupp.mapDomain f u → coeff u_1 φ = 0
⊢ False

tactic: simp at h hu
state_before: case intro.intro
σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
u : σ →₀ ℕ
hu : u ∈ φ.support
h : coeff u φ = 0
⊢ False

tactic: contradiction
state_before: case intro.intro
σ : Type u_1
τ : Type u_3
α : Type ?u.944555
R : Type u_2
S : Type ?u.944561
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
u : σ →₀ ℕ
h : coeff u φ = 0
hu : ¬↑φ u = 0
⊢ False
Theorem: List.length_insert_of_not_mem
File: Std/Data/List/Lemmas.lean

tactic: rw [insert_of_not_mem h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : ¬a ∈ l
⊢ length (List.insert a l) = length l + 1

tactic: rfl
state_before: α : Type u_1
inst✝ : DecidableEq α
a : α
l : List α
h : ¬a ∈ l
⊢ length (a :: l) = length l + 1
Theorem: Matrix.ker_diagonal_toLin'
File: Mathlib/LinearAlgebra/Matrix/Diagonal.lean

tactic: rw [← comap_bot, ← iInf_ker_proj, comap_iInf]
state_before: m : Type u_1
n : Type ?u.94396
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
⊢ ker (↑toLin' (diagonal w)) = ⨆ (i : m) (_ : i ∈ {i | w i = 0}), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: have := fun i : m => ker_comp (toLin' (diagonal w)) (proj i)
state_before: m : Type u_1
n : Type ?u.94396
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
⊢ (⨅ (i : m), comap (↑toLin' (diagonal w)) (ker (proj i))) =
    ⨆ (i : m) (_ : i ∈ {i | w i = 0}), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: simp only [comap_iInf, ← this, proj_diagonal, ker_smul']
state_before: m : Type u_1
n : Type ?u.94396
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
this : ∀ (i : m), ker (comp (proj i) (↑toLin' (diagonal w))) = comap (↑toLin' (diagonal w)) (ker (proj i))
⊢ (⨅ (i : m), comap (↑toLin' (diagonal w)) (ker (proj i))) =
    ⨆ (i : m) (_ : i ∈ {i | w i = 0}), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: have : univ ⊆ { i : m | w i = 0 } ∪ { i : m | w i = 0 }ᶜ := by rw [Set.union_compl_self]
state_before: m : Type u_1
n : Type ?u.94396
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
this : ∀ (i : m), ker (comp (proj i) (↑toLin' (diagonal w))) = comap (↑toLin' (diagonal w)) (ker (proj i))
⊢ (⨅ (i : m) (_ : w i ≠ 0), ker (proj i)) =
    ⨆ (i : m) (_ : i ∈ {i | w i = 0}), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: exact (iSup_range_stdBasis_eq_iInf_ker_proj K (fun _ : m => K) disjoint_compl_right this
  (Set.toFinite _)).symm
state_before: m : Type u_1
n : Type ?u.94396
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
this✝ : ∀ (i : m), ker (comp (proj i) (↑toLin' (diagonal w))) = comap (↑toLin' (diagonal w)) (ker (proj i))
this : univ ⊆ {i | w i = 0} ∪ {i | w i = 0}ᶜ
⊢ (⨅ (i : m) (_ : w i ≠ 0), ker (proj i)) =
    ⨆ (i : m) (_ : i ∈ {i | w i = 0}), LinearMap.range (LinearMap.stdBasis K (fun x => K) i)

tactic: rw [Set.union_compl_self]
state_before: m : Type u_1
n : Type ?u.94396
inst✝³ : Fintype m
inst✝² : Fintype n
K : Type u
inst✝¹ : Semifield K
inst✝ : DecidableEq m
w : m → K
this : ∀ (i : m), ker (comp (proj i) (↑toLin' (diagonal w))) = comap (↑toLin' (diagonal w)) (ker (proj i))
⊢ univ ⊆ {i | w i = 0} ∪ {i | w i = 0}ᶜ
Theorem: Nat.Partrec.Code.eval_curry
File: Mathlib/Computability/PartrecCode.lean

tactic: simp! [Seq.seq]
state_before: c : Code
n x : ℕ
⊢ eval (curry c n) x = eval c (Nat.pair n x)
Theorem: round_int_add
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [add_comm, round_add_int, add_comm]
state_before: F : Type ?u.258044
α : Type u_1
β : Type ?u.258050
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
y : ℤ
⊢ round (↑y + x) = y + round x
Theorem: CategoryTheory.IsIso.hom_inv_id_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp [← Category.assoc]
state_before: C : Type u
inst✝ : Category C
X Y Z✝ : C
f : X ⟶ Y
I : IsIso f
Z : C
g : X ⟶ Z
⊢ f ≫ inv f ≫ g = g
Theorem: Cardinal.mk_quaternionAlgebra
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [mk_congr (QuaternionAlgebra.equivProd c₁ c₂)]
state_before: R : Type u_1
c₁ c₂ : R
⊢ (#ℍ[R,c₁,c₂]) = (#R) ^ 4

tactic: simp only [mk_prod, lift_id]
state_before: R : Type u_1
c₁ c₂ : R
⊢ (#R × R × R × R) = (#R) ^ 4

tactic: ring
state_before: R : Type u_1
c₁ c₂ : R
⊢ (#R) * ((#R) * ((#R) * (#R))) = (#R) ^ 4
Theorem: CategoryTheory.CosimplicialObject.δ_comp_σ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (↑Fin.castSucc i) ≫ σ X i = 𝟙 (X.obj [n])

tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_σ_self, X.map_id]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.δ (↑Fin.castSucc i)) ≫ X.map (SimplexCategory.σ i) = 𝟙 (X.obj [n])
Theorem: CategoryTheory.exact_of_zero
File: Mathlib/Algebra/Homology/Exact.lean

tactic: obtain rfl : f = 0 := by ext
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f✝ : A✝ ⟶ B
g✝ : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
f : A ⟶ 0
g : 0 ⟶ C
⊢ Exact f g

tactic: obtain rfl : g = 0 := by ext
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f : A✝ ⟶ B
g✝ : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
g : 0 ⟶ C
⊢ Exact 0 g

tactic: fconstructor
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f : A✝ ⟶ B
g : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
⊢ Exact 0 0

tactic: ext
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f✝ : A✝ ⟶ B
g✝ : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
f : A ⟶ 0
g : 0 ⟶ C
⊢ f = 0

tactic: ext
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f : A✝ ⟶ B
g✝ : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
g : 0 ⟶ C
⊢ g = 0

tactic: simp
state_before: case w
V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f : A✝ ⟶ B
g : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
⊢ 0 ≫ 0 = 0

tactic: exact imageToKernel_epi_of_zero_of_mono 0
state_before: case epi
V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B C✝ D : V
f : A✝ ⟶ B
g : B ⟶ C✝
h : C✝ ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A C : V
⊢ Epi (imageToKernel 0 0 (_ : 0 ≫ 0 = 0))
Theorem: iteratedFDeriv_one_apply
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [iteratedFDeriv_succ_apply_right, iteratedFDeriv_zero_apply]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
m : Fin 1 → E
⊢ ↑(iteratedFDeriv 𝕜 1 f x) m = ↑(fderiv 𝕜 f x) (m 0)

tactic: rfl
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
m : Fin 1 → E
⊢ ↑(fderiv 𝕜 f x) (m (last 0)) = ↑(fderiv 𝕜 f x) (m 0)
Theorem: MeasureTheory.integral_piecewise
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [← Set.indicator_add_compl_eq_piecewise,
  integral_add' (hf.integrable_indicator hs) (hg.integrable_indicator hs.compl),
  integral_indicator hs, integral_indicator hs.compl]
state_before: α : Type u_1
β : Type ?u.49654
E : Type u_2
F : Type ?u.49660
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : IntegrableOn f s
hg : IntegrableOn g (sᶜ)
⊢ (∫ (x : α), piecewise s f g x ∂μ) = (∫ (x : α) in s, f x ∂μ) + ∫ (x : α) in sᶜ, g x ∂μ
Theorem: Module.isTorsionBySet_iff_is_torsion_by_span
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [isTorsionBySet_iff_torsionBySet_eq_top, isTorsionBySet_iff_torsionBySet_eq_top,
  torsionBySet_eq_torsionBySet_span]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ IsTorsionBySet R M s ↔ IsTorsionBySet R M ↑(Ideal.span s)
Theorem: UpperSet.Ici_sSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [mem_Ici_iff, mem_iSup_iff, sSup_le_iff]
state_before: α : Type u_1
β : Type ?u.114658
γ : Type ?u.114661
ι : Sort ?u.114664
κ : ι → Sort ?u.114669
inst✝ : CompleteLattice α
S : Set α
c : α
⊢ c ∈ Ici (sSup S) ↔ c ∈ ⨆ (a : α) (_ : a ∈ S), Ici a
Theorem: MvPolynomial.rename_prod_mk_eval₂
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: intros
state_before: case h_X
σ : Type u_1
τ : Type u_3
α : Type ?u.592987
R : Type u_2
S : Type ?u.592993
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
j : τ
g : σ → MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    ↑(rename (Prod.mk j)) (eval₂ C g p) = eval₂ C (fun x => ↑(rename (Prod.mk j)) (g x)) p →
      ↑(rename (Prod.mk j)) (eval₂ C g (p * X n)) = eval₂ C (fun x => ↑(rename (Prod.mk j)) (g x)) (p * X n)

tactic: simp [*]
state_before: case h_X
σ : Type u_1
τ : Type u_3
α : Type ?u.592987
R : Type u_2
S : Type ?u.592993
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
j : τ
g : σ → MvPolynomial σ R
p✝ : MvPolynomial σ R
n✝ : σ
a✝ : ↑(rename (Prod.mk j)) (eval₂ C g p✝) = eval₂ C (fun x => ↑(rename (Prod.mk j)) (g x)) p✝
⊢ ↑(rename (Prod.mk j)) (eval₂ C g (p✝ * X n✝)) = eval₂ C (fun x => ↑(rename (Prod.mk j)) (g x)) (p✝ * X n✝)
Theorem: Int.le_of_add_le_add_right
File: Std/Data/Int/Lemmas.lean

tactic: rwa [Int.add_comm b a, Int.add_comm b c]
state_before: a b c : Int
h : a + b ≤ c + b
⊢ b + a ≤ b + c
Theorem: Equiv.Perm.closure_isSwap
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: cases nonempty_fintype α
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Finite α
⊢ Subgroup.closure {σ | IsSwap σ} = ⊤

tactic: refine' eq_top_iff.mpr fun x _ => _
state_before: case intro
α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Finite α
val✝ : Fintype α
⊢ Subgroup.closure {σ | IsSwap σ} = ⊤

tactic: obtain ⟨h1, h2⟩ := Subtype.mem (truncSwapFactors x).out
state_before: case intro
α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Finite α
val✝ : Fintype α
x : Perm α
x✝ : x ∈ ⊤
⊢ x ∈ Subgroup.closure {σ | IsSwap σ}

tactic: rw [← h1]
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Finite α
val✝ : Fintype α
x : Perm α
x✝ : x ∈ ⊤
h1 : List.prod ↑(Trunc.out (truncSwapFactors x)) = x
h2 : ∀ (g : Perm α), g ∈ ↑(Trunc.out (truncSwapFactors x)) → IsSwap g
⊢ x ∈ Subgroup.closure {σ | IsSwap σ}

tactic: exact Subgroup.list_prod_mem _ fun y hy => Subgroup.subset_closure (h2 y hy)
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : Finite α
val✝ : Fintype α
x : Perm α
x✝ : x ∈ ⊤
h1 : List.prod ↑(Trunc.out (truncSwapFactors x)) = x
h2 : ∀ (g : Perm α), g ∈ ↑(Trunc.out (truncSwapFactors x)) → IsSwap g
⊢ List.prod ↑(Trunc.out (truncSwapFactors x)) ∈ Subgroup.closure {σ | IsSwap σ}
Theorem: Function.Injective.nonempty_apply_iff
File: Mathlib/Data/Set/Basic.lean

tactic: rw [nonempty_iff_ne_empty, ← h2, nonempty_iff_ne_empty, hf.ne_iff]
state_before: ι : Sort ?u.234525
α : Type u_1
β : Type u_2
f✝ : α → β
f : Set α → Set β
hf : Injective f
h2 : f ∅ = ∅
s : Set α
⊢ Set.Nonempty (f s) ↔ Set.Nonempty s
Theorem: MeasureTheory.FinMeasAdditive.smul
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp [hT s t hs ht hμs hμt hst]
state_before: α : Type u_3
E : Type ?u.20126
F : Type ?u.20129
F' : Type ?u.20132
G : Type ?u.20135
𝕜 : Type u_1
p : ℝ≥0∞
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
inst✝³ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝² : AddCommMonoid β
T T' : Set α → β
inst✝¹ : Monoid 𝕜
inst✝ : DistribMulAction 𝕜 β
hT : FinMeasAdditive μ T
c : 𝕜
s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
hμs : ↑↑μ s ≠ ⊤
hμt : ↑↑μ t ≠ ⊤
hst : s ∩ t = ∅
⊢ (fun s => c • T s) (s ∪ t) = (fun s => c • T s) s + (fun s => c • T s) t
Theorem: CategoryTheory.epi_of_epi
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: constructor
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi (f ≫ g)
⊢ Epi g

tactic: intro Z a b w
state_before: case left_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi (f ≫ g)
⊢ ∀ {Z_1 : C} (g_1 h : Z ⟶ Z_1), g ≫ g_1 = g ≫ h → g_1 = h

tactic: replace w := congr_arg (fun k => f ≫ k) w
state_before: case left_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : g ≫ a = g ≫ b
⊢ a = b

tactic: dsimp at w
state_before: case left_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : (fun k => f ≫ k) (g ≫ a) = (fun k => f ≫ k) (g ≫ b)
⊢ a = b

tactic: rw [← Category.assoc, ← Category.assoc] at w
state_before: case left_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : f ≫ g ≫ a = f ≫ g ≫ b
⊢ a = b

tactic: exact (cancel_epi _).1 w
state_before: case left_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : (f ≫ g) ≫ a = (f ≫ g) ≫ b
⊢ a = b
Theorem: IsSemiringHom.id
File: Mathlib/Deprecated/Ring.lean

tactic: refine' { .. } <;> intros <;> rfl
state_before: α : Type u
β : Type v
inst✝¹ : Semiring α
inst✝ : Semiring β
f : α → β
hf : IsSemiringHom f
x y : α
⊢ IsSemiringHom _root_.id
Theorem: Ordinal.log_zero_right
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [log_def b1, ← Ordinal.le_zero, pred_le]
state_before: b : Ordinal
b1 : 1 < b
⊢ log b 0 = 0

tactic: apply csInf_le'
state_before: b : Ordinal
b1 : 1 < b
⊢ sInf {o | 0 < b ^ o} ≤ succ 0

tactic: dsimp
state_before: case h
b : Ordinal
b1 : 1 < b
⊢ succ 0 ∈ {o | 0 < b ^ o}

tactic: rw [succ_zero, opow_one]
state_before: case h
b : Ordinal
b1 : 1 < b
⊢ 0 < b ^ succ 0

tactic: exact zero_lt_one.trans b1
state_before: case h
b : Ordinal
b1 : 1 < b
⊢ 0 < b

tactic: simp only [log_of_not_one_lt_left b1]
state_before: b : Ordinal
b1 : ¬1 < b
⊢ log b 0 = 0
Theorem: List.permutationsAux_cons
File: Mathlib/Data/List/Permutation.lean

tactic: rw [permutationsAux, permutationsAux.rec]
state_before: α : Type u_1
β : Type ?u.26869
t : α
ts is : List α
⊢ permutationsAux (t :: ts) is =
    foldr (fun y r => (permutationsAux2 t ts r y id).snd) (permutationsAux ts (t :: is)) (permutations is)

tactic: rfl
state_before: α : Type u_1
β : Type ?u.26869
t : α
ts is : List α
⊢ foldr (fun y r => (permutationsAux2 t ts r y id).snd)
      (permutationsAux.rec (fun x => [])
        (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).snd) IH1 (is :: IH2)) ts (t :: is))
      (is ::
        permutationsAux.rec (fun x => [])
          (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).snd) IH1 (is :: IH2)) is []) =
    foldr (fun y r => (permutationsAux2 t ts r y id).snd)
      (permutationsAux.rec (fun x => [])
        (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).snd) IH1 (is :: IH2)) ts (t :: is))
      (permutations is)