tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.NatTrans.mapHomotopyCategory_comp
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

tactic: aesop_cat
state_before: ι : Type u_1
V : Type u
inst✝⁶ : Category V
inst✝⁵ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝⁴ : Category W
inst✝³ : Preadditive W
c : ComplexShape ι
F G H : V ⥤ W
inst✝² : Functor.Additive F
inst✝¹ : Functor.Additive G
inst✝ : Functor.Additive H
α : F ⟶ G
β : G ⟶ H
⊢ mapHomotopyCategory (α ≫ β) c = mapHomotopyCategory α c ≫ mapHomotopyCategory β c
Theorem: Finset.smul_finset_subset_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← coe_subset]
state_before: F : Type ?u.837747
α : Type u_2
β : Type u_1
γ : Type ?u.837756
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ a • s ⊆ t ↔ s ⊆ a⁻¹ • t

tactic: push_cast
state_before: F : Type ?u.837747
α : Type u_2
β : Type u_1
γ : Type ?u.837756
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑(a • s) ⊆ ↑t ↔ ↑s ⊆ ↑(a⁻¹ • t)

tactic: exact Set.set_smul_subset_iff
state_before: F : Type ?u.837747
α : Type u_2
β : Type u_1
γ : Type ?u.837756
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ a • ↑s ⊆ ↑t ↔ ↑s ⊆ a⁻¹ • ↑t
Theorem: Int.natAbs_negOfNat
File: Std/Data/Int/Lemmas.lean

tactic: cases n <;> rfl
state_before: n : Nat
⊢ natAbs (negOfNat n) = n
Theorem: Real.cosh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cosh]
state_before: x y : ℝ
⊢ cosh 0 = 1
Theorem: Real.arccos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos, sub_eq_zero]
state_before: x : ℝ
⊢ arccos x = 0 ↔ 1 ≤ x
Theorem: MeasureTheory.AEEqFun.comp₂_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [comp₂_eq_pair, pair_eq_mk, comp_mk]
state_before: α : Type u_4
β : Type u_2
γ : Type u_1
δ : Type u_3
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ → δ
hg : Continuous (uncurry g)
f₁ : α →ₘ[μ] β
f₂ : α →ₘ[μ] γ
⊢ comp₂ g hg f₁ f₂ = mk (fun a => g (↑f₁ a) (↑f₂ a)) (_ : AEStronglyMeasurable (fun x => uncurry g (↑f₁ x, ↑f₂ x)) μ)

tactic: rfl
state_before: α : Type u_4
β : Type u_2
γ : Type u_1
δ : Type u_3
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ → δ
hg : Continuous (uncurry g)
f₁ : α →ₘ[μ] β
f₂ : α →ₘ[μ] γ
⊢ mk (uncurry g ∘ fun x => (↑f₁ x, ↑f₂ x)) (_ : AEStronglyMeasurable (fun x => uncurry g (↑f₁ x, ↑f₂ x)) μ) =
    mk (fun a => g (↑f₁ a) (↑f₂ a)) (_ : AEStronglyMeasurable (fun x => uncurry g (↑f₁ x, ↑f₂ x)) μ)
Theorem: LucasLehmer.sMod_mod
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: cases i <;> simp [sMod]
state_before: p i : ℕ
⊢ sMod p i % (2 ^ p - 1) = sMod p i
Theorem: Fin.map_valEmbedding_Ici
File: Mathlib/Data/Fin/Interval.lean

tactic: ext x
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ici a) = Icc (↑a) (n - 1)

tactic: simp only [exists_prop, Embedding.coe_subtype, mem_Ici, mem_map, mem_Icc]
state_before: case a
n : ℕ
a b : Fin n
x : ℕ
⊢ x ∈ map valEmbedding (Ici a) ↔ x ∈ Icc (↑a) (n - 1)

tactic: constructor
state_before: case a
n : ℕ
a b : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ ↑valEmbedding a_1 = x) ↔ ↑a ≤ x ∧ x ≤ n - 1

tactic: cases n
state_before: case a.mpr
n : ℕ
a b : Fin n
x : ℕ
⊢ ↑a ≤ x ∧ x ≤ n - 1 → ∃ a_2, a ≤ a_2 ∧ ↑valEmbedding a_2 = x

tactic: rintro ⟨x, hx, rfl⟩
state_before: case a.mp
n : ℕ
a b : Fin n
x : ℕ
⊢ (∃ a_1, a ≤ a_1 ∧ ↑valEmbedding a_1 = x) → ↑a ≤ x ∧ x ≤ n - 1

tactic: exact ⟨hx, le_tsub_of_add_le_right <| x.2⟩
state_before: case a.mp.intro.intro
n : ℕ
a b x : Fin n
hx : a ≤ x
⊢ ↑a ≤ ↑valEmbedding x ∧ ↑valEmbedding x ≤ n - 1

tactic: exact Fin.elim0 a
state_before: case a.mpr.zero
x : ℕ
a b : Fin Nat.zero
⊢ ↑a ≤ x ∧ x ≤ Nat.zero - 1 → ∃ a_2, a ≤ a_2 ∧ ↑valEmbedding a_2 = x

tactic: exact fun hx => ⟨⟨x, Nat.lt_succ_iff.2 hx.2⟩, hx.1, rfl⟩
state_before: case a.mpr.succ
x n✝ : ℕ
a b : Fin (Nat.succ n✝)
⊢ ↑a ≤ x ∧ x ≤ Nat.succ n✝ - 1 → ∃ a_2, a ≤ a_2 ∧ ↑valEmbedding a_2 = x
Theorem: Finset.disjoint_insert_right
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [disjoint_insert_left, _root_.disjoint_comm]
state_before: α : Type u_1
β : Type ?u.126146
γ : Type ?u.126149
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ _root_.Disjoint (insert a t) s ↔ ¬a ∈ s ∧ _root_.Disjoint s t
Theorem: IsPathConnected.exists_path_through_family'
File: Mathlib/Topology/PathConnected.lean

tactic: rcases h.exists_path_through_family p hp with ⟨γ, hγ⟩
state_before: X✝ : Type ?u.681883
Y : Type ?u.681886
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.681901
F : Set X✝
X : Type u_1
inst✝ : TopologicalSpace X
n : ℕ
s : Set X
h : IsPathConnected s
p : Fin (n + 1) → X
hp : ∀ (i : Fin (n + 1)), p i ∈ s
⊢ ∃ γ t, (∀ (t : ↑I), ↑γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: rcases hγ with ⟨h₁, h₂⟩
state_before: case intro
X✝ : Type ?u.681883
Y : Type ?u.681886
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.681901
F : Set X✝
X : Type u_1
inst✝ : TopologicalSpace X
n : ℕ
s : Set X
h : IsPathConnected s
p : Fin (n + 1) → X
hp : ∀ (i : Fin (n + 1)), p i ∈ s
γ : Path (p 0) (p ↑n)
hγ : range ↑γ ⊆ s ∧ ∀ (i : Fin (n + 1)), p i ∈ range ↑γ
⊢ ∃ γ t, (∀ (t : ↑I), ↑γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: simp only [range, mem_setOf_eq] at h₂
state_before: case intro.intro
X✝ : Type ?u.681883
Y : Type ?u.681886
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.681901
F : Set X✝
X : Type u_1
inst✝ : TopologicalSpace X
n : ℕ
s : Set X
h : IsPathConnected s
p : Fin (n + 1) → X
hp : ∀ (i : Fin (n + 1)), p i ∈ s
γ : Path (p 0) (p ↑n)
h₁ : range ↑γ ⊆ s
h₂ : ∀ (i : Fin (n + 1)), p i ∈ range ↑γ
⊢ ∃ γ t, (∀ (t : ↑I), ↑γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: rw [range_subset_iff] at h₁
state_before: case intro.intro
X✝ : Type ?u.681883
Y : Type ?u.681886
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.681901
F : Set X✝
X : Type u_1
inst✝ : TopologicalSpace X
n : ℕ
s : Set X
h : IsPathConnected s
p : Fin (n + 1) → X
hp : ∀ (i : Fin (n + 1)), p i ∈ s
γ : Path (p 0) (p ↑n)
h₁ : range ↑γ ⊆ s
h₂ : ∀ (i : Fin (n + 1)), ∃ y, ↑γ y = p i
⊢ ∃ γ t, (∀ (t : ↑I), ↑γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: choose! t ht using h₂
state_before: case intro.intro
X✝ : Type ?u.681883
Y : Type ?u.681886
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.681901
F : Set X✝
X : Type u_1
inst✝ : TopologicalSpace X
n : ℕ
s : Set X
h : IsPathConnected s
p : Fin (n + 1) → X
hp : ∀ (i : Fin (n + 1)), p i ∈ s
γ : Path (p 0) (p ↑n)
h₁ : ∀ (y : ↑I), ↑γ y ∈ s
h₂ : ∀ (i : Fin (n + 1)), ∃ y, ↑γ y = p i
⊢ ∃ γ t, (∀ (t : ↑I), ↑γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), ↑γ (t i) = p i

tactic: exact ⟨γ, t, h₁, ht⟩
state_before: case intro.intro
X✝ : Type ?u.681883
Y : Type ?u.681886
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.681901
F : Set X✝
X : Type u_1
inst✝ : TopologicalSpace X
n : ℕ
s : Set X
h : IsPathConnected s
p : Fin (n + 1) → X
hp : ∀ (i : Fin (n + 1)), p i ∈ s
γ : Path (p 0) (p ↑n)
h₁ : ∀ (y : ↑I), ↑γ y ∈ s
t : Fin (n + 1) → ↑I
ht : ∀ (i : Fin (n + 1)), ↑γ (t i) = p i
⊢ ∃ γ t, (∀ (t : ↑I), ↑γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), ↑γ (t i) = p i
Theorem: collinear_pair
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_iff_exists_forall_eq_smul_vadd]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
⊢ Collinear k {p₁, p₂}

tactic: use p₁, p₂ -ᵥ p₁
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
⊢ ∃ p₀ v, ∀ (p : P), p ∈ {p₁, p₂} → ∃ r, p = r • v +ᵥ p₀

tactic: intro p hp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
⊢ ∀ (p : P), p ∈ {p₁, p₂} → ∃ r, p = r • (p₂ -ᵥ p₁) +ᵥ p₁

tactic: rw [Set.mem_insert_iff, Set.mem_singleton_iff] at hp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p : P
hp : p ∈ {p₁, p₂}
⊢ ∃ r, p = r • (p₂ -ᵥ p₁) +ᵥ p₁

tactic: cases' hp with hp hp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p : P
hp : p = p₁ ∨ p = p₂
⊢ ∃ r, p = r • (p₂ -ᵥ p₁) +ᵥ p₁

tactic: use 0
state_before: case inl
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p : P
hp : p = p₁
⊢ ∃ r, p = r • (p₂ -ᵥ p₁) +ᵥ p₁

tactic: simp [hp]
state_before: case inl
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p : P
hp : p = p₁
⊢ p = 0 • (p₂ -ᵥ p₁) +ᵥ p₁

tactic: use 1
state_before: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p : P
hp : p = p₂
⊢ ∃ r, p = r • (p₂ -ᵥ p₁) +ᵥ p₁

tactic: simp [hp]
state_before: case inr
k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.267878
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p : P
hp : p = p₂
⊢ p = 1 • (p₂ -ᵥ p₁) +ᵥ p₁
Theorem: Complex.exp_eq_exp_iff_exp_sub_eq_one
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [exp_sub, div_eq_one_iff_eq (exp_ne_zero _)]
state_before: x y : ℂ
⊢ exp x = exp y ↔ exp (x - y) = 1
Theorem: AddCircle.coe_eq_zero_iff
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: simp [AddSubgroup.mem_zmultiples_iff]
state_before: 𝕜 : Type u_1
B : Type ?u.32898
inst✝² : LinearOrderedAddCommGroup 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p x : 𝕜
⊢ ↑x = 0 ↔ ∃ n, n • p = x
Theorem: Int.ediv_left_inj
File: Std/Data/Int/DivMod.lean

tactic: rw [← Int.mul_ediv_cancel' hda, ← Int.mul_ediv_cancel' hdb, h]
state_before: a b d : Int
hda : d ∣ a
hdb : d ∣ b
h : a / d = b / d
⊢ a = b
Theorem: PosNum.cmp_eq
File: Mathlib/Data/Num/Lemmas.lean

tactic: have := cmp_to_nat m n
state_before: α : Type ?u.392175
m n : PosNum
⊢ cmp m n = Ordering.eq ↔ m = n

tactic: revert this
state_before: α : Type ?u.392175
m n : PosNum
this : Ordering.casesOn (cmp m n) (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ cmp m n = Ordering.eq ↔ m = n

tactic: cases cmp m n <;> intro this <;> simp at this ⊢ <;> try { exact this } <;>
simp [show m ≠ n from fun e => by rw [e] at this;exact lt_irrefl _ this]
state_before: α : Type ?u.392175
m n : PosNum
⊢ Ordering.casesOn (cmp m n) (↑m < ↑n) (m = n) (↑n < ↑m) → (cmp m n = Ordering.eq ↔ m = n)

tactic: rw [e] at this
state_before: α : Type ?u.392175
m n : PosNum
this : ↑n < ↑m
e : m = n
⊢ False

tactic: exact lt_irrefl _ this
state_before: α : Type ?u.392175
m n : PosNum
this : ↑n < ↑n
e : m = n
⊢ False
Theorem: Basis.sum_repr_mul_repr
File: Mathlib/LinearAlgebra/Basis.lean

tactic: conv_rhs => rw [← b'.sum_repr x]
state_before: ι : Type u_4
ι'✝ : Type ?u.761324
R : Type u_2
R₂ : Type ?u.761330
K : Type ?u.761333
M : Type u_3
M' : Type ?u.761339
M'' : Type ?u.761342
V : Type u
V' : Type ?u.761347
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b : Basis ι R M
b'✝ : Basis ι'✝ R M'
ι' : Type u_1
inst✝ : Fintype ι'
b' : Basis ι' R M
x : M
i : ι
⊢ ∑ j : ι', ↑(↑b.repr (↑b' j)) i * ↑(↑b'.repr x) j = ↑(↑b.repr x) i

tactic: simp_rw [LinearEquiv.map_sum, LinearEquiv.map_smul, Finset.sum_apply']
state_before: ι : Type u_4
ι'✝ : Type ?u.761324
R : Type u_2
R₂ : Type ?u.761330
K : Type ?u.761333
M : Type u_3
M' : Type ?u.761339
M'' : Type ?u.761342
V : Type u
V' : Type ?u.761347
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b : Basis ι R M
b'✝ : Basis ι'✝ R M'
ι' : Type u_1
inst✝ : Fintype ι'
b' : Basis ι' R M
x : M
i : ι
⊢ ∑ j : ι', ↑(↑b.repr (↑b' j)) i * ↑(↑b'.repr x) j = ↑(↑b.repr (∑ i : ι', ↑(↑b'.repr x) i • ↑b' i)) i

tactic: refine' Finset.sum_congr rfl fun j _ => _
state_before: ι : Type u_4
ι'✝ : Type ?u.761324
R : Type u_2
R₂ : Type ?u.761330
K : Type ?u.761333
M : Type u_3
M' : Type ?u.761339
M'' : Type ?u.761342
V : Type u
V' : Type ?u.761347
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b : Basis ι R M
b'✝ : Basis ι'✝ R M'
ι' : Type u_1
inst✝ : Fintype ι'
b' : Basis ι' R M
x : M
i : ι
⊢ ∑ x_1 : ι', ↑(↑b.repr (↑b' x_1)) i * ↑(↑b'.repr x) x_1 = ∑ x_1 : ι', ↑(↑(↑b'.repr x) x_1 • ↑b.repr (↑b' x_1)) i

tactic: rw [Finsupp.smul_apply, smul_eq_mul, mul_comm]
state_before: ι : Type u_4
ι'✝ : Type ?u.761324
R : Type u_2
R₂ : Type ?u.761330
K : Type ?u.761333
M : Type u_3
M' : Type ?u.761339
M'' : Type ?u.761342
V : Type u
V' : Type ?u.761347
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b : Basis ι R M
b'✝ : Basis ι'✝ R M'
ι' : Type u_1
inst✝ : Fintype ι'
b' : Basis ι' R M
x : M
i : ι
j : ι'
x✝ : j ∈ Finset.univ
⊢ ↑(↑b.repr (↑b' j)) i * ↑(↑b'.repr x) j = ↑(↑(↑b'.repr x) j • ↑b.repr (↑b' j)) i
Theorem: ZMod.natAbs_valMinAbs_add_le
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' n with n
state_before: n✝ a✝ n : ℕ
a b : ZMod n
⊢ Int.natAbs (valMinAbs (a + b)) ≤ Int.natAbs (valMinAbs a + valMinAbs b)

tactic: apply natAbs_min_of_le_div_two n.succ
state_before: case succ
n✝ a✝ n : ℕ
a b : ZMod (Nat.succ n)
⊢ Int.natAbs (valMinAbs (a + b)) ≤ Int.natAbs (valMinAbs a + valMinAbs b)

tactic: rfl
state_before: case zero
n a✝ : ℕ
a b : ZMod Nat.zero
⊢ Int.natAbs (valMinAbs (a + b)) ≤ Int.natAbs (valMinAbs a + valMinAbs b)

tactic: simp_rw [Int.cast_add, coe_valMinAbs]
state_before: case succ.he
n✝ a✝ n : ℕ
a b : ZMod (Nat.succ n)
⊢ ↑(valMinAbs (a + b)) = ↑(valMinAbs a + valMinAbs b)

tactic: apply natAbs_valMinAbs_le
state_before: case succ.hl
n✝ a✝ n : ℕ
a b : ZMod (Nat.succ n)
⊢ Int.natAbs (valMinAbs (a + b)) ≤ Nat.succ n / 2
Theorem: Finset.prod_list_count_of_subset
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [prod_list_count]
state_before: ι : Type ?u.498342
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : List α
s : Finset α
hs : toFinset m ⊆ s
⊢ prod m = ∏ i in s, i ^ count i m

tactic: refine' prod_subset hs fun x _ hx => _
state_before: ι : Type ?u.498342
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : List α
s : Finset α
hs : toFinset m ⊆ s
⊢ ∏ m_1 in toFinset m, m_1 ^ count m_1 m = ∏ i in s, i ^ count i m

tactic: rw [mem_toFinset] at hx
state_before: ι : Type ?u.498342
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : List α
s : Finset α
hs : toFinset m ⊆ s
x : α
x✝ : x ∈ s
hx : ¬x ∈ toFinset m
⊢ x ^ count x m = 1

tactic: rw [count_eq_zero_of_not_mem hx, pow_zero]
state_before: ι : Type ?u.498342
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : List α
s : Finset α
hs : toFinset m ⊆ s
x : α
x✝ : x ∈ s
hx : ¬x ∈ m
⊢ x ^ count x m = 1
Theorem: TypeVec.snd_diag
File: Mathlib/Data/TypeVec.lean

tactic: funext i
state_before: n : ℕ
α : TypeVec n
⊢ prod.snd ⊚ prod.diag = id

tactic: induction i
state_before: case h
n : ℕ
α : TypeVec n
i : Fin2 n
⊢ (prod.snd ⊚ prod.diag) i = id i

tactic: case fz => rfl
state_before: case h.fz
n n✝ : ℕ
α : TypeVec (succ n✝)
⊢ (prod.snd ⊚ prod.diag) Fin2.fz = id Fin2.fz

case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝}, (prod.snd ⊚ prod.diag) a✝ = id a✝
α : TypeVec (succ n✝)
⊢ (prod.snd ⊚ prod.diag) (Fin2.fs a✝) = id (Fin2.fs a✝)

tactic: case fs _ _ i_ih => apply i_ih
state_before: case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝}, (prod.snd ⊚ prod.diag) a✝ = id a✝
α : TypeVec (succ n✝)
⊢ (prod.snd ⊚ prod.diag) (Fin2.fs a✝) = id (Fin2.fs a✝)

tactic: rfl
state_before: n n✝ : ℕ
α : TypeVec (succ n✝)
⊢ (prod.snd ⊚ prod.diag) Fin2.fz = id Fin2.fz

tactic: apply i_ih
state_before: n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec n✝}, (prod.snd ⊚ prod.diag) a✝ = id a✝
α : TypeVec (succ n✝)
⊢ (prod.snd ⊚ prod.diag) (Fin2.fs a✝) = id (Fin2.fs a✝)
Theorem: MeasureTheory.IntegrableOn.add_measure
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: delta IntegrableOn
state_before: α : Type u_1
β : Type ?u.1518598
E : Type u_2
F : Type ?u.1518604
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
hμ : IntegrableOn f s
hν : IntegrableOn f s
⊢ IntegrableOn f s

tactic: rw [Measure.restrict_add]
state_before: α : Type u_1
β : Type ?u.1518598
E : Type u_2
F : Type ?u.1518604
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
hμ : IntegrableOn f s
hν : IntegrableOn f s
⊢ Integrable f

tactic: exact hμ.integrable.add_measure hν
state_before: α : Type u_1
β : Type ?u.1518598
E : Type u_2
F : Type ?u.1518604
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
hμ : IntegrableOn f s
hν : IntegrableOn f s
⊢ Integrable f
Theorem: LocalEquiv.refl_prod_refl
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: ext ⟨x, y⟩ <;> simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.63296
δ : Type ?u.63299
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ prod (LocalEquiv.refl α) (LocalEquiv.refl β) = LocalEquiv.refl (α × β)
Theorem: LatticeOrderedCommGroup.mabs_sup_div_sup_le_mabs
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: apply le_of_mul_le_of_one_le_left
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ abs ((a ⊔ c) / (b ⊔ c)) ≤ abs (a / b)

tactic: rw [abs_div_sup_mul_abs_div_inf]
state_before: case h
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ abs ((a ⊔ c) / (b ⊔ c)) * ?b ≤ abs (a / b)

tactic: exact one_le_abs _
state_before: case hle
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 1 ≤ abs ((a ⊓ c) / (b ⊓ c))
Theorem: intervalIntegral.sum_integral_adjacent_intervals
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [← Nat.Ico_zero_eq_range]
state_before: ι : Type ?u.15613852
𝕜 : Type ?u.15613855
E : Type u_1
F : Type ?u.15613861
A : Type ?u.15613864
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a : ℕ → ℝ
n : ℕ
hint : ∀ (k : ℕ), k < n → IntervalIntegrable f μ (a k) (a (k + 1))
⊢ (∑ k in Finset.range n, ∫ (x : ℝ) in a k..a (k + 1), f x ∂μ) = ∫ (x : ℝ) in a 0 ..a n, f x ∂μ

tactic: exact sum_integral_adjacent_intervals_Ico (zero_le n) fun k hk => hint k hk.2
state_before: ι : Type ?u.15613852
𝕜 : Type ?u.15613855
E : Type u_1
F : Type ?u.15613861
A : Type ?u.15613864
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a✝ b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
a : ℕ → ℝ
n : ℕ
hint : ∀ (k : ℕ), k < n → IntervalIntegrable f μ (a k) (a (k + 1))
⊢ (∑ k in Finset.Ico 0 n, ∫ (x : ℝ) in a k..a (k + 1), f x ∂μ) = ∫ (x : ℝ) in a 0 ..a n, f x ∂μ
Theorem: disjoint_symmDiff_inf
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type ?u.59758
α : Type u_1
β : Type ?u.59764
π : ι → Type ?u.59769
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ Disjoint (a ∆ b) (a ⊓ b)

tactic: exact disjoint_sdiff_self_left
state_before: ι : Type ?u.59758
α : Type u_1
β : Type ?u.59764
π : ι → Type ?u.59769
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ Disjoint ((a ⊔ b) \ (a ⊓ b)) (a ⊓ b)
Theorem: ZMod.valMinAbs_natAbs_eq_min
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [valMinAbs_def_pos]
state_before: n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
⊢ Int.natAbs (valMinAbs a) = min (val a) (n - val a)

tactic: split_ifs with h
state_before: n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
⊢ Int.natAbs (if val a ≤ n / 2 then ↑(val a) else ↑(val a) - ↑n) = min (val a) (n - val a)

tactic: rw [Int.natAbs_ofNat]
state_before: case inl
n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : val a ≤ n / 2
⊢ Int.natAbs ↑(val a) = min (val a) (n - val a)

tactic: symm
state_before: case inl
n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : val a ≤ n / 2
⊢ val a = min (val a) (n - val a)

tactic: apply
  min_eq_left (le_trans h (le_trans (Nat.half_le_of_sub_le_half _) (Nat.sub_le_sub_left n h)))
state_before: case inl
n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : val a ≤ n / 2
⊢ min (val a) (n - val a) = val a

tactic: rw [Nat.sub_sub_self (Nat.div_le_self _ _)]
state_before: n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : val a ≤ n / 2
⊢ n - (n - n / 2) ≤ n / 2

tactic: rw [← Int.natAbs_neg, neg_sub, ← Nat.cast_sub a.val_le]
state_before: case inr
n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : ¬val a ≤ n / 2
⊢ Int.natAbs (↑(val a) - ↑n) = min (val a) (n - val a)

tactic: symm
state_before: case inr
n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : ¬val a ≤ n / 2
⊢ Int.natAbs ↑(n - val a) = min (val a) (n - val a)

tactic: apply
  min_eq_right
    (le_trans (le_trans (Nat.sub_le_sub_left n (lt_of_not_ge h)) (Nat.le_half_of_half_lt_sub _))
      (le_of_not_ge h))
state_before: case inr
n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : ¬val a ≤ n / 2
⊢ min (val a) (n - val a) = Int.natAbs ↑(n - val a)

tactic: rw [Nat.sub_sub_self (Nat.div_lt_self (lt_of_le_of_ne' (Nat.zero_le _) hpos.1) one_lt_two)]
state_before: n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : ¬val a ≤ n / 2
⊢ n / 2 < n - (n - Nat.succ (n / 2))

tactic: apply Nat.lt_succ_self
state_before: n✝ a✝ n : ℕ
hpos : NeZero n
a : ZMod n
h : ¬val a ≤ n / 2
⊢ n / 2 < Nat.succ (n / 2)
Theorem: Finset.codisjoint_left
File: Mathlib/Data/Fintype/Basic.lean

tactic: classical simp [codisjoint_iff, eq_univ_iff_forall, or_iff_not_imp_left]
state_before: α : Type u_1
β : Type ?u.4270
γ : Type ?u.4273
inst✝ : Fintype α
s t : Finset α
⊢ Codisjoint s t ↔ ∀ ⦃a : α⦄, ¬a ∈ s → a ∈ t

tactic: simp [codisjoint_iff, eq_univ_iff_forall, or_iff_not_imp_left]
state_before: α : Type u_1
β : Type ?u.4270
γ : Type ?u.4273
inst✝ : Fintype α
s t : Finset α
⊢ Codisjoint s t ↔ ∀ ⦃a : α⦄, ¬a ∈ s → a ∈ t