tasksource/leandojo huggingface dataset:
Theorem: openSegment_subset_Ioo
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rintro z ⟨a, b, ha, hb, hab, rfl⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
⊢ openSegment 𝕜 x y ⊆ Ioo x y

tactic: constructor
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y ∈ Ioo x y

tactic: calc
  x = a • x + b • x := (Convex.combo_self hab _).symm
  _ < a • x + b • y := by gcongr
state_before: case intro.intro.intro.intro.intro.left
𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ x < a • x + b • y

case intro.intro.intro.intro.intro.right
𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y < y

tactic: calc
  a • x + b • y < a • y + b • y := by gcongr
  _ = y := Convex.combo_self hab _
state_before: case intro.intro.intro.intro.intro.right
𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y < y

tactic: gcongr
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • x < a • x + b • y

tactic: gcongr
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.250125
G : Type ?u.250128
ι : Type ?u.250131
π : ι → Type ?u.250136
inst✝³ : OrderedSemiring 𝕜
inst✝² : OrderedCancelAddCommMonoid E
inst✝¹ : Module 𝕜 E
inst✝ : OrderedSMul 𝕜 E
x y : E
h : x < y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x + b • y < a • y + b • y
Theorem: Equiv.Perm.cycleType_le_of_mem_cycleFactorsFinset
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: have hf' := mem_cycleFactorsFinset_iff.1 hf
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ cycleFactorsFinset g
⊢ cycleType f ≤ cycleType g

tactic: rw [cycleType_def, cycleType_def, hf'.left.cycleFactorsFinset_eq_singleton]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ cycleFactorsFinset g
hf' : IsCycle f ∧ ∀ (a : α), a ∈ support f → ↑f a = ↑g a
⊢ cycleType f ≤ cycleType g

tactic: refine map_le_map ?_
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ cycleFactorsFinset g
hf' : IsCycle f ∧ ∀ (a : α), a ∈ support f → ↑f a = ↑g a
⊢ map (Finset.card ∘ support) {f}.val ≤ map (Finset.card ∘ support) (cycleFactorsFinset g).val

tactic: simpa only [Finset.singleton_val, singleton_le, Finset.mem_val] using hf
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
f g : Perm α
hf : f ∈ cycleFactorsFinset g
hf' : IsCycle f ∧ ∀ (a : α), a ∈ support f → ↑f a = ↑g a
⊢ {f}.val ≤ (cycleFactorsFinset g).val
Theorem: Int.even_mul
File: Mathlib/Data/Int/Parity.lean

tactic: cases' emod_two_eq_zero_or_one m with h₁ h₁ <;>
cases' emod_two_eq_zero_or_one n with h₂ h₂ <;>
simp [even_iff, h₁, h₂, Int.mul_emod]
state_before: m n : ℤ
⊢ Even (m * n) ↔ Even m ∨ Even n
Theorem: Complex.closure_reProdIm
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [← preimage_eq_preimage equivRealProdClm.symm.toHomeomorph.surjective,
  equivRealProdClm.symm.toHomeomorph.preimage_closure] using @closure_prod_eq _ _ _ _ s t
state_before: s t : Set ℝ
⊢ closure (s ×ℂ t) = closure s ×ℂ closure t
Theorem: LinearIndependent.image_of_comp
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: nontriviality R
state_before: ι✝ : Type u'
ι'✝ : Type ?u.248228
R : Type u_3
K : Type ?u.248234
M : Type u_4
M' : Type ?u.248240
M'' : Type ?u.248243
V : Type u
V' : Type ?u.248248
v : ι✝ → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
ι : Type u_1
ι' : Type u_2
s : Set ι
f : ι → ι'
g : ι' → M
hs : LinearIndependent R fun x => g (f ↑x)
⊢ LinearIndependent R fun x => g ↑x

tactic: have : InjOn f s := injOn_iff_injective.2 hs.injective.of_comp
state_before: ι✝ : Type u'
ι'✝ : Type ?u.248228
R : Type u_3
K : Type ?u.248234
M : Type u_4
M' : Type ?u.248240
M'' : Type ?u.248243
V : Type u
V' : Type ?u.248248
v : ι✝ → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
ι : Type u_1
ι' : Type u_2
s : Set ι
f : ι → ι'
g : ι' → M
hs : LinearIndependent R fun x => g (f ↑x)
✝ : Nontrivial R
⊢ LinearIndependent R fun x => g ↑x

tactic: exact (linearIndependent_equiv' (Equiv.Set.imageOfInjOn f s this) rfl).1 hs
state_before: ι✝ : Type u'
ι'✝ : Type ?u.248228
R : Type u_3
K : Type ?u.248234
M : Type u_4
M' : Type ?u.248240
M'' : Type ?u.248243
V : Type u
V' : Type ?u.248248
v : ι✝ → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
ι : Type u_1
ι' : Type u_2
s : Set ι
f : ι → ι'
g : ι' → M
hs : LinearIndependent R fun x => g (f ↑x)
✝ : Nontrivial R
this : InjOn f s
⊢ LinearIndependent R fun x => g ↑x
Theorem: SimpleGraph.IsSRGWith.compl_is_regular
File: Mathlib/Combinatorics/SimpleGraph/StronglyRegular.lean

tactic: rw [← h.card, Nat.sub_sub, add_comm, ← Nat.sub_sub]
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : IsSRGWith G n k ℓ μ
⊢ IsRegularOfDegree (Gᶜ) (n - k - 1)

tactic: exact h.regular.compl
state_before: V : Type u
inst✝² : Fintype V
inst✝¹ : DecidableEq V
G : SimpleGraph V
inst✝ : DecidableRel G.Adj
n k ℓ μ : ℕ
h : IsSRGWith G n k ℓ μ
⊢ IsRegularOfDegree (Gᶜ) (Fintype.card V - 1 - k)
Theorem: PresentedGroup.toGroup.unique
File: Mathlib/GroupTheory/PresentedGroup.lean

tactic: intro x
state_before: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ (r : FreeGroup α), r ∈ rels → ↑(↑FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), ↑g (PresentedGroup.of x) = f x
⊢ ∀ {x : PresentedGroup rels}, ↑g x = ↑(toGroup h) x

tactic: refine' QuotientGroup.induction_on x _
state_before: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ (r : FreeGroup α), r ∈ rels → ↑(↑FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), ↑g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ ↑g x = ↑(toGroup h) x

tactic: exact fun _ ↦ FreeGroup.lift.unique (g.comp (QuotientGroup.mk' _)) hg
state_before: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ (r : FreeGroup α), r ∈ rels → ↑(↑FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), ↑g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ ∀ (z : FreeGroup α), ↑g ↑z = ↑(toGroup h) ↑z
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow_comp
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: rw [← equalizerSubobject_arrow, Category.assoc, Category.assoc, equalizer.condition]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ arrow (equalizerSubobject f g) ≫ f = arrow (equalizerSubobject f g) ≫ g
Theorem: padicNormE.norm_p
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [← @Rat.cast_coe_nat ℝ _ p]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑p‖ = (↑p)⁻¹

tactic: rw [← @Rat.cast_coe_nat ℚ_[p] _ p]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑p‖ = (↑↑p)⁻¹

tactic: simp [hp.1.ne_zero, hp.1.ne_one, norm, padicNorm, padicValRat, padicValInt, zpow_neg,
  -Rat.cast_coe_nat]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑↑p‖ = (↑↑p)⁻¹
Theorem: Matrix.dotProduct_diagonal'
File: Mathlib/Data/Matrix/Basic.lean

tactic: have : ∀ (j) (_ : j ≠ i), v j * diagonal w j i = 0 := fun j hij => by
  simp [diagonal_apply_ne _ hij]
state_before: l : Type ?u.157202
m : Type u_1
n : Type ?u.157208
o : Type ?u.157211
m' : o → Type ?u.157216
n' : o → Type ?u.157221
R : Type ?u.157224
S : Type ?u.157227
α : Type v
β : Type w
γ : Type ?u.157234
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
⊢ (v ⬝ᵥ fun j => diagonal w j i) = v i * w i

tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
state_before: l : Type ?u.157202
m : Type u_1
n : Type ?u.157208
o : Type ?u.157211
m' : o → Type ?u.157216
n' : o → Type ?u.157221
R : Type ?u.157224
S : Type ?u.157227
α : Type v
β : Type w
γ : Type ?u.157234
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → v j * diagonal w j i = 0
⊢ (v ⬝ᵥ fun j => diagonal w j i) = v i * w i

tactic: simp [diagonal_apply_ne _ hij]
state_before: l : Type ?u.157202
m : Type u_1
n : Type ?u.157208
o : Type ?u.157211
m' : o → Type ?u.157216
n' : o → Type ?u.157221
R : Type ?u.157224
S : Type ?u.157227
α : Type v
β : Type w
γ : Type ?u.157234
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i j : m
hij : j ≠ i
⊢ v j * diagonal w j i = 0
Theorem: FreeAbelianGroup.toFinsupp_toFreeAbelianGroup
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: rw [← AddMonoidHom.comp_apply, toFinsupp_comp_toFreeAbelianGroup, AddMonoidHom.id_apply]
state_before: X : Type u_1
f : X →₀ ℤ
⊢ ↑toFinsupp (↑toFreeAbelianGroup f) = f
Theorem: Metric.infDist_le_dist_of_mem
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [dist_edist, infDist]
state_before: ι : Sort ?u.59705
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : y ∈ s
⊢ infDist x s ≤ dist x y

tactic: exact ENNReal.toReal_mono (edist_ne_top _ _) (infEdist_le_edist_of_mem h)
state_before: ι : Sort ?u.59705
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : y ∈ s
⊢ ENNReal.toReal (infEdist x s) ≤ ENNReal.toReal (edist x y)
Theorem: Polynomial.cyclotomic_prime
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: suffices cyclotomic p ℤ = ∑ i in range p, X ^ i by
  simpa only [map_cyclotomic_int, Polynomial.map_sum, Polynomial.map_pow, Polynomial.map_X] using
    congr_arg (map (Int.castRingHom R)) this
state_before: R : Type u_1
inst✝ : Ring R
p : ℕ
hp : Fact (Nat.Prime p)
⊢ cyclotomic p R = ∑ i in range p, X ^ i

tactic: rw [← prod_cyclotomic_eq_geom_sum hp.out.pos, hp.out.divisors,
  erase_insert (mem_singleton.not.2 hp.out.ne_one.symm), prod_singleton]
state_before: R : Type u_1
inst✝ : Ring R
p : ℕ
hp : Fact (Nat.Prime p)
⊢ cyclotomic p ℤ = ∑ i in range p, X ^ i

tactic: simpa only [map_cyclotomic_int, Polynomial.map_sum, Polynomial.map_pow, Polynomial.map_X] using
  congr_arg (map (Int.castRingHom R)) this
state_before: R : Type u_1
inst✝ : Ring R
p : ℕ
hp : Fact (Nat.Prime p)
this : cyclotomic p ℤ = ∑ i in range p, X ^ i
⊢ cyclotomic p R = ∑ i in range p, X ^ i
Theorem: Ideal.isUnit_iff
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [mul_top, h]
state_before: R : Type u
ι : Type ?u.390157
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
h : I = ⊤
⊢ ⊤ = I * ⊤
Theorem: List.foldr_const
File: Mathlib/Logic/Function/Iterate.lean

tactic: rw [length_cons, foldr, foldr_const f b l, iterate_succ_apply']
state_before: α : Type u
β : Type v
f : β → β
b : β
a : α
l : List α
⊢ foldr (fun x => f) b (a :: l) = (f^[length (a :: l)]) b
Theorem: Int.sub_ediv_of_dvd
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.sub_eq_add_neg, Int.sub_eq_add_neg, Int.add_ediv_of_dvd_right (Int.dvd_neg.2 hcb)]
state_before: a b c : Int
hcb : c ∣ b
⊢ (a - b) / c = a / c - b / c

tactic: congr
state_before: a b c : Int
hcb : c ∣ b
⊢ a / c + -b / c = a / c + -(b / c)

tactic: exact Int.neg_ediv_of_dvd hcb
state_before: case e_a
a b c : Int
hcb : c ∣ b
⊢ -b / c = -(b / c)
Theorem: Nat.add_one_le_ceil_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← Nat.lt_ceil, Nat.add_one_le_iff]
state_before: F : Type ?u.45139
α : Type u_1
β : Type ?u.45145
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ n + 1 ≤ ⌈a⌉₊ ↔ ↑n < a
Theorem: Asymptotics.IsBigO.sum
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def] at *
state_before: α : Type u_2
β : Type ?u.594284
E : Type ?u.594287
F : Type u_4
G : Type ?u.594293
E' : Type u_3
F' : Type ?u.594299
G' : Type ?u.594302
E'' : Type ?u.594305
F'' : Type ?u.594308
G'' : Type ?u.594311
R : Type ?u.594314
R' : Type ?u.594317
𝕜 : Type ?u.594320
𝕜' : Type ?u.594323
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Type u_1
A : ι → α → E'
C : ι → ℝ
s : Finset ι
h : ∀ (i : ι), i ∈ s → A i =O[l] g
⊢ (fun x => ∑ i in s, A i x) =O[l] g

tactic: choose! C hC using h
state_before: α : Type u_2
β : Type ?u.594284
E : Type ?u.594287
F : Type u_4
G : Type ?u.594293
E' : Type u_3
F' : Type ?u.594299
G' : Type ?u.594302
E'' : Type ?u.594305
F'' : Type ?u.594308
G'' : Type ?u.594311
R : Type ?u.594314
R' : Type ?u.594317
𝕜 : Type ?u.594320
𝕜' : Type ?u.594323
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Type u_1
A : ι → α → E'
C : ι → ℝ
s : Finset ι
h : ∀ (i : ι), i ∈ s → ∃ c, IsBigOWith c l (A i) g
⊢ ∃ c, IsBigOWith c l (fun x => ∑ i in s, A i x) g

tactic: exact ⟨_, IsBigOWith.sum hC⟩
state_before: α : Type u_2
β : Type ?u.594284
E : Type ?u.594287
F : Type u_4
G : Type ?u.594293
E' : Type u_3
F' : Type ?u.594299
G' : Type ?u.594302
E'' : Type ?u.594305
F'' : Type ?u.594308
G'' : Type ?u.594311
R : Type ?u.594314
R' : Type ?u.594317
𝕜 : Type ?u.594320
𝕜' : Type ?u.594323
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Type u_1
A : ι → α → E'
C✝ : ι → ℝ
s : Finset ι
C : ι → ℝ
hC : ∀ (i : ι), i ∈ s → IsBigOWith (C i) l (A i) g
⊢ ∃ c, IsBigOWith c l (fun x => ∑ i in s, A i x) g
Theorem: FreeMonoid.comp_lift
File: Mathlib/Algebra/FreeMonoid/Basic.lean

tactic: simp
state_before: α : Type u_3
β : Type ?u.36837
γ : Type ?u.36840
M : Type u_1
inst✝¹ : Monoid M
N : Type u_2
inst✝ : Monoid N
g : M →* N
f : α → M
⊢ ∀ (x : α), ↑(MonoidHom.comp g (↑lift f)) (of x) = ↑(↑lift (↑g ∘ f)) (of x)
Theorem: IsGroupHom.inv_ker_one
File: Mathlib/Deprecated/Subgroup.lean

tactic: have : f a * (f b)⁻¹ = 1 := by rw [h, mul_right_inv]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.74216
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ f (a * b⁻¹) = 1

tactic: rwa [← hf.map_inv, ← hf.map_mul] at this
state_before: G : Type u_1
H : Type u_2
A : Type ?u.74216
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
this : f a * (f b)⁻¹ = 1
⊢ f (a * b⁻¹) = 1

tactic: rw [h, mul_right_inv]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.74216
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
h : f a = f b
⊢ f a * (f b)⁻¹ = 1
Theorem: MeasureTheory.SignedMeasure.restrictNonposSeq_measurableSet
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [restrictNonposSeq]
state_before: case succ
α : Type u_1
β : Type ?u.36367
inst✝³ : MeasurableSpace α
M : Type ?u.36373
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasurableSet (MeasureTheory.SignedMeasure.restrictNonposSeq s i (Nat.succ n✝))

tactic: exact someExistsOneDivLT_measurableSet
state_before: case succ
α : Type u_1
β : Type ?u.36367
inst✝³ : MeasurableSpace α
M : Type ?u.36373
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasurableSet
    (MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \
        ⋃ (k : ℕ) (H : k ≤ n✝),
          let_fun this := (_ : k < Nat.succ n✝);
          MeasureTheory.SignedMeasure.restrictNonposSeq s i k))
Theorem: norm_div_pos_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [(norm_nonneg' _).lt_iff_ne, ne_comm]
state_before: 𝓕 : Type ?u.1226823
𝕜 : Type ?u.1226826
α : Type ?u.1226829
ι : Type ?u.1226832
κ : Type ?u.1226835
E : Type u_1
F : Type ?u.1226841
G : Type ?u.1226844
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ 0 < ‖a / b‖ ↔ a ≠ b

tactic: exact norm_div_eq_zero_iff.not
state_before: 𝓕 : Type ?u.1226823
𝕜 : Type ?u.1226826
α : Type ?u.1226829
ι : Type ?u.1226832
κ : Type ?u.1226835
E : Type u_1
F : Type ?u.1226841
G : Type ?u.1226844
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ ‖a / b‖ ≠ 0 ↔ a ≠ b
Theorem: MeasureTheory.Measure.restrict_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← measure_univ_eq_zero, restrict_apply_univ]
state_before: α : Type u_1
β : Type ?u.292265
γ : Type ?u.292268
δ : Type ?u.292271
ι : Type ?u.292274
R : Type ?u.292277
R' : Type ?u.292280
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ restrict μ s = 0 ↔ ↑↑μ s = 0
Theorem: Set.ite_inter
File: Mathlib/Data/Set/Basic.lean

tactic: rw [ite_inter_inter, ite_same]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁✝ s₂✝ t✝ t₁ t₂ u t s₁ s₂ s : Set α
⊢ Set.ite t (s₁ ∩ s) (s₂ ∩ s) = Set.ite t s₁ s₂ ∩ s
Theorem: Finset.range_filter_eq
File: Mathlib/Data/Finset/Basic.lean

tactic: convert filter_eq (range n) m using 2
state_before: α : Type ?u.433649
β : Type ?u.433652
γ : Type ?u.433655
n✝ m✝ l n m : ℕ
⊢ filter (fun x => x = m) (range n) = if m < n then {m} else ∅

tactic: ext
state_before: case h.e'_2.h.e'_2
α : Type ?u.433649
β : Type ?u.433652
γ : Type ?u.433655
n✝ m✝ l n m : ℕ
⊢ (fun x => x = m) = Eq m

tactic: rw [eq_comm]
state_before: case h.e'_2.h.e'_2.h.a
α : Type ?u.433649
β : Type ?u.433652
γ : Type ?u.433655
n✝ m✝ l n m x✝ : ℕ
⊢ x✝ = m ↔ m = x✝

tactic: simp
state_before: case h.e'_3.h₁.a
α : Type ?u.433649
β : Type ?u.433652
γ : Type ?u.433655
n✝ m✝ l n m : ℕ
⊢ m < n ↔ m ∈ range n
Theorem: UniformGroup.toUniformSpace_eq
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: ext : 1
state_before: G✝ : Type ?u.426706
inst✝⁴ : CommGroup G✝
inst✝³ : TopologicalSpace G✝
inst✝² : TopologicalGroup G✝
G : Type u_1
u : UniformSpace G
inst✝¹ : Group G
inst✝ : UniformGroup G
⊢ TopologicalGroup.toUniformSpace G = u

tactic: rw [uniformity_eq_comap_nhds_one' G, uniformity_eq_comap_nhds_one G]
state_before: case a
G✝ : Type ?u.426706
inst✝⁴ : CommGroup G✝
inst✝³ : TopologicalSpace G✝
inst✝² : TopologicalGroup G✝
G : Type u_1
u : UniformSpace G
inst✝¹ : Group G
inst✝ : UniformGroup G
⊢ 𝓤 G = 𝓤 G
Theorem: WittVector.mapFun.nat_cast
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: induction n <;> simp [*, Nat.unaryCast, add, one, zero] <;> rfl
state_before: p : ℕ
R : Type u_2
S : Type u_1
T : Type ?u.510348
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.510363
β : Type ?u.510366
f : R →+* S
x y : 𝕎 R
n : ℕ
⊢ mapFun (↑f) (Nat.unaryCast n) = ↑n
Theorem: Finset.one_lt_card
File: Mathlib/Data/Finset/Card.lean

tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type ?u.55273
s t : Finset α
f : α → β
n : ℕ
⊢ 1 < card s ↔ ∃ a, a ∈ s ∧ ∃ b, b ∈ s ∧ a ≠ b

tactic: push_neg
state_before: α : Type u_1
β : Type ?u.55273
s t : Finset α
f : α → β
n : ℕ
⊢ ¬1 < card s ↔ ¬∃ a, a ∈ s ∧ ∃ b, b ∈ s ∧ a ≠ b

tactic: exact card_le_one
state_before: α : Type u_1
β : Type ?u.55273
s t : Finset α
f : α → β
n : ℕ
⊢ card s ≤ 1 ↔ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ s → a = b
Theorem: AlgebraicGeometry.PresheafedSpace.id_c_app
File: Mathlib/AlgebraicGeometry/PresheafedSpace.lean

tactic: rw [id_c, map_id]
state_before: C : Type u_1
inst✝ : Category C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X).c.app U = X.presheaf.map (𝟙 U)

tactic: rfl
state_before: C : Type u_1
inst✝ : Category C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X.presheaf).app U = 𝟙 (X.presheaf.obj U)
Theorem: IsArtinian.range_smul_pow_stabilizes
File: Mathlib/RingTheory/Artinian.lean

tactic: dsimp at hy⊢
state_before: R : Type u_2
M : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
n m : ℕ
h : n ≤ m
x : M
x✝ : x ∈ (fun n => LinearMap.range (r ^ n • LinearMap.id)) m
y : M
hy : ↑(r ^ m • LinearMap.id) y = x
⊢ ↑(r ^ n • LinearMap.id) (r ^ (m - n) • y) = x

tactic: rw [← smul_assoc, smul_eq_mul, ← pow_add, ← hy, add_tsub_cancel_of_le h]
state_before: R : Type u_2
M : Type u_1
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
n m : ℕ
h : n ≤ m
x : M
x✝ : x ∈ (fun n => LinearMap.range (r ^ n • LinearMap.id)) m
y : M
hy : r ^ m • y = x
⊢ r ^ n • r ^ (m - n) • y = x
Theorem: Int.pred_neg_pred
File: Mathlib/Data/Int/Basic.lean

tactic: rw [neg_pred, pred_succ]
state_before: a : ℤ
⊢ pred (-pred a) = -a
Theorem: Turing.ToPartrec.Code.nil_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [nil]
state_before: v : List ℕ
⊢ eval nil v = pure []
Theorem: orderOf_eq_zero_iff'
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simp_rw [orderOf_eq_zero_iff, isOfFinOrder_iff_pow_eq_one, not_exists, not_and]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
⊢ orderOf x = 0 ↔ ∀ (n : ℕ), 0 < n → x ^ n ≠ 1
Theorem: lt_div_iff_of_neg'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, lt_div_iff_of_neg hc]
state_before: ι : Type ?u.148442
α : Type u_1
β : Type ?u.148448
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ a < b / c ↔ b < c * a