1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.centerMass_pair
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp only [centerMass, sum_pair hne, smul_add, (mul_smul _ _ _).symm, div_eq_inv_mul]
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
hne : i ≠ j
⊢ {i, j}.centerMass w z = (w i / (w i + w j)) • z i + (w j / (w i + w j)) • z j
state_after: no goals
Theorem: Ideal.torsionOf_eq_bot_iff_of_noZeroSMulDivisors
File: Mathlib/Algebra/Module/Torsion.lean

tactic: refine ⟨fun h contra => ?_, fun h => (Submodule.eq_bot_iff _).mpr fun r hr => ?_⟩
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
⊢ torsionOf R M m = ⊥ ↔ m ≠ 0
state_after: case refine_1
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : torsionOf R M m = ⊥
contra : m = 0
⊢ False

case refine_2
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : m ≠ 0
r : R
hr : r ∈ torsionOf R M m
⊢ r = 0

tactic: rw [contra, torsionOf_zero] at h
state_before: case refine_1
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : torsionOf R M m = ⊥
contra : m = 0
⊢ False
state_after: case refine_1
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : ⊤ = ⊥
contra : m = 0
⊢ False

tactic: exact bot_ne_top.symm h
state_before: case refine_1
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : ⊤ = ⊥
contra : m = 0
⊢ False
state_after: no goals

tactic: rw [mem_torsionOf_iff, smul_eq_zero] at hr
state_before: case refine_2
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : m ≠ 0
r : R
hr : r ∈ torsionOf R M m
⊢ r = 0
state_after: case refine_2
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : m ≠ 0
r : R
hr : r = 0 ∨ m = 0
⊢ r = 0

tactic: tauto
state_before: case refine_2
R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
m : M
h : m ≠ 0
r : R
hr : r = 0 ∨ m = 0
⊢ r = 0
state_after: no goals
Theorem: perfectSpace_iff_forall_not_isolated
File: Mathlib/Topology/Perfect.lean

tactic: simp [perfectSpace_def, Preperfect, AccPt]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
⊢ PerfectSpace X ↔ ∀ (x : X), (𝓝[≠] x).NeBot
state_after: no goals
Theorem: PadicInt.exists_pow_neg_lt
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: obtain ⟨k, hk⟩ := exists_nat_gt ε⁻¹
state_before: p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
⊢ ∃ k, ↑p ^ (-↑k) < ε
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ∃ k, ↑p ^ (-↑k) < ε

tactic: use k
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ∃ k, ↑p ^ (-↑k) < ε
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ↑p ^ (-↑k) < ε

tactic: rw [← inv_lt_inv hε (_root_.zpow_pos_of_pos _ _)]
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ↑p ^ (-↑k) < ε
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ε⁻¹ < (↑p ^ (-↑k))⁻¹

p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ 0 < ↑p

tactic: rw [zpow_neg, inv_inv, zpow_natCast]
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ε⁻¹ < (↑p ^ (-↑k))⁻¹
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ε⁻¹ < ↑p ^ k

tactic: apply lt_of_lt_of_le hk
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ε⁻¹ < ↑p ^ k
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ↑k ≤ ↑p ^ k

tactic: norm_cast
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ ↑k ≤ ↑p ^ k
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ k ≤ p ^ k

tactic: apply le_of_lt
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ k ≤ p ^ k
state_after: case h.a
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ k < p ^ k

tactic: convert Nat.lt_pow_self _ _ using 1
state_before: case h.a
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ k < p ^ k
state_after: case h.a.convert_2
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ 1 < p

tactic: exact hp.1.one_lt
state_before: case h.a.convert_2
p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ 1 < p
state_after: no goals

tactic: exact mod_cast hp.1.pos
state_before: p : ℕ
hp : Fact (Nat.Prime p)
ε : ℝ
hε : 0 < ε
k : ℕ
hk : ε⁻¹ < ↑k
⊢ 0 < ↑p
state_after: no goals
Theorem: Cardinal.nat_eq_lift_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_natCast.{v,u} n, lift_inj]
state_before: α β : Type u
n : ℕ
a : Cardinal.{u}
⊢ ↑n = lift.{v, u} a ↔ ↑n = a
state_after: no goals
Theorem: CategoryTheory.Limits.image.factor_map
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
f g : Arrow C
inst✝² : HasImage f.hom
inst✝¹ : HasImage g.hom
sq : f ⟶ g
inst✝ : HasImageMap sq
⊢ factorThruImage f.hom ≫ map sq = sq.left ≫ factorThruImage g.hom
state_after: no goals
Theorem: LinearOrderedField.cutMap_self
File: Mathlib/Algebra/Order/CompleteField.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a : α
⊢ cutMap α a = Iio a ∩ range Rat.cast
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ cutMap α a ↔ x✝ ∈ Iio a ∩ range Rat.cast

tactic: constructor
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ cutMap α a ↔ x✝ ∈ Iio a ∩ range Rat.cast
state_after: case h.mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ cutMap α a → x✝ ∈ Iio a ∩ range Rat.cast

case h.mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ Iio a ∩ range Rat.cast → x✝ ∈ cutMap α a

tactic: rintro ⟨q, h, rfl⟩
state_before: case h.mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ cutMap α a → x✝ ∈ Iio a ∩ range Rat.cast
state_after: case h.mp.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
a : α
q : ℚ
h : q ∈ {t | ↑t < a}
⊢ ↑q ∈ Iio a ∩ range Rat.cast

tactic: exact ⟨h, q, rfl⟩
state_before: case h.mp.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
a : α
q : ℚ
h : q ∈ {t | ↑t < a}
⊢ ↑q ∈ Iio a ∩ range Rat.cast
state_after: no goals

tactic: rintro ⟨h, q, rfl⟩
state_before: case h.mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q : ℚ
a x✝ : α
⊢ x✝ ∈ Iio a ∩ range Rat.cast → x✝ ∈ cutMap α a
state_after: case h.mpr.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
a : α
q : ℚ
h : ↑q ∈ Iio a
⊢ ↑q ∈ cutMap α a

tactic: exact ⟨q, h, rfl⟩
state_before: case h.mpr.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : LinearOrderedField α
inst✝ : DivisionRing β
a✝ a₁ a₂ : α
b : β
q✝ : ℚ
a : α
q : ℚ
h : ↑q ∈ Iio a
⊢ ↑q ∈ cutMap α a
state_after: no goals
Theorem: IsClosedMap.id
File: Mathlib/Topology/Maps.lean

tactic: rwa [image_id]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
s : Set X
hs : IsClosed s
⊢ IsClosed (id '' s)
state_after: no goals
Theorem: Int.fract_div_mul_self_add_zsmul_eq
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [zsmul_eq_mul, ← add_mul, fract_add_floor, div_mul_cancel₀ b ha]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
z : ℤ
a✝ : α
k : Type u_4
inst✝¹ : LinearOrderedField k
inst✝ : FloorRing k
b✝ a b : k
ha : a ≠ 0
⊢ fract (b / a) * a + ⌊b / a⌋ • a = b
state_after: no goals
Theorem: Cardinal.eq_of_add_eq_of_aleph0_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply le_antisymm
state_before: a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b = c
state_after: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b ≤ c

case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ c ≤ b

tactic: rw [← not_lt]
state_before: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ c ≤ b
state_after: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ ¬b < c

tactic: intro hb
state_before: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ ¬b < c
state_after: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
hb : b < c
⊢ False

tactic: have : a + b < c := add_lt_of_lt hc ha hb
state_before: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
hb : b < c
⊢ False
state_after: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
hb : b < c
this : a + b < c
⊢ False

tactic: simp [h, lt_irrefl] at this
state_before: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
hb : b < c
this : a + b < c
⊢ False
state_after: no goals

tactic: rw [← h]
state_before: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b ≤ c
state_after: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b ≤ a + b

tactic: apply self_le_add_left
state_before: case a
a b c : Cardinal.{u_1}
h : a + b = c
ha : a < c
hc : ℵ₀ ≤ c
⊢ b ≤ a + b
state_after: no goals
Theorem: List.formPerm_apply_get_zero
File: Mathlib/GroupTheory/Perm/List.lean

tactic: omega
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ 0 < l.length
state_after: no goals

tactic: simp_all [formPerm_apply_getElem_zero]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ l.formPerm (l.get ⟨0, ⋯⟩) = l.get ⟨1, hl⟩
state_after: no goals
Theorem: Ordnode.findMax_dual
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← findMin_dual, dual_dual]
state_before: α : Type u_1
t : Ordnode α
⊢ t.dual.findMax = t.findMin
state_after: no goals
Theorem: compare_ge_iff_ge
File: Mathlib/Init/Order/Defs.lean

tactic: cases h : compare a b <;> simp
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b ≠ Ordering.lt ↔ a ≥ b
state_after: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ a < b

case eq
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.eq
⊢ b ≤ a

case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ b ≤ a

tactic: exact compare_lt_iff_lt.1 h
state_before: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ a < b
state_after: no goals

tactic: exact le_of_lt <| compare_gt_iff_gt.1 h
state_before: case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ b ≤ a
state_after: no goals
Theorem: Real.logb_inv
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp [logb, neg_div]
state_before: b x✝ y x : ℝ
⊢ logb b x⁻¹ = -logb b x
state_after: no goals
Theorem: Set.preimage_sInter
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [sInter_eq_biInter, preimage_iInter₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : Set (Set β)
⊢ f ⁻¹' ⋂₀ s = ⋂ t ∈ s, f ⁻¹' t
state_after: no goals
Theorem: bddAbove_lowerClosure
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [BddAbove, upperBounds_lowerClosure]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
⊢ BddAbove ↑(lowerClosure s) ↔ BddAbove s
state_after: no goals
Theorem: Surreal.bddAbove_of_small
File: Mathlib/SetTheory/Surreal/Basic.lean

tactic: simpa using bddAbove_range_of_small (Subtype.val : s → Surreal.{u})
state_before: s : Set Surreal
inst✝ : Small.{u, u + 1} ↑s
⊢ BddAbove s
state_after: no goals
Theorem: Fin.le_zero_iff'
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [Nat.eq_zero_of_le_zero h]
state_before: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
h : k ≤ 0
⊢ ↑k = ↑0
state_after: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
h : k ≤ 0
⊢ 0 = ↑0

tactic: rfl
state_before: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
h : k ≤ 0
⊢ 0 = ↑0
state_after: no goals

tactic: rintro rfl
state_before: n✝ m n : ℕ
inst✝ : NeZero n
k : Fin n
⊢ k = 0 → k ≤ 0
state_after: n✝ m n : ℕ
inst✝ : NeZero n
⊢ 0 ≤ 0

tactic: exact Nat.le_refl _
state_before: n✝ m n : ℕ
inst✝ : NeZero n
⊢ 0 ≤ 0
state_after: no goals
Theorem: MulLECancellable.le_mul_iff_one_le_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

tactic: rw [i.symm_op, ha.le_mul_iff_one_le_right]
state_before: α : Type u_1
β : Type u_2
inst✝² : LE α
inst✝¹ : MulOneClass α
i : IsSymmOp α α fun x x_1 => x * x_1
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a ≤ b * a ↔ 1 ≤ b
state_after: no goals
Theorem: Filter.Tendsto.tendstoUniformlyOnFilter_const
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simpa only [nhds_eq_comap_uniformity, tendsto_comap_iff] using hg.comp (tendsto_fst (g := p'))
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p'✝ : Filter α
g✝ : ι → α
g : ι → β
b : β
hg : Tendsto g p (𝓝 b)
p' : Filter α
⊢ TendstoUniformlyOnFilter (fun n x => g n) (fun x => b) p p'
state_after: no goals
Theorem: List.prod_rotate_eq_one_of_prod_eq_one
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
x✝¹ : [].prod = 1
x✝ : ℕ
⊢ ([].rotate x✝).prod = 1
state_after: no goals

tactic: have : n % List.length (a :: l) ≤ List.length (a :: l) := le_of_lt (Nat.mod_lt _ (by simp))
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
a : G
l : List G
hl : (a :: l).prod = 1
n : ℕ
⊢ ((a :: l).rotate n).prod = 1
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
a : G
l : List G
hl : (a :: l).prod = 1
n : ℕ
this : n % (a :: l).length ≤ (a :: l).length
⊢ ((a :: l).rotate n).prod = 1

tactic: rw [← List.take_append_drop (n % List.length (a :: l)) (a :: l)] at hl
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
a : G
l : List G
hl : (a :: l).prod = 1
n : ℕ
this : n % (a :: l).length ≤ (a :: l).length
⊢ ((a :: l).rotate n).prod = 1
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
a : G
l : List G
n : ℕ
hl : (take (n % (a :: l).length) (a :: l) ++ drop (n % (a :: l).length) (a :: l)).prod = 1
this : n % (a :: l).length ≤ (a :: l).length
⊢ ((a :: l).rotate n).prod = 1

tactic: rw [← rotate_mod, rotate_eq_drop_append_take this, List.prod_append, mul_eq_one_iff_inv_eq, ←
  one_mul (List.prod _)⁻¹, ← hl, List.prod_append, mul_assoc, mul_inv_self, mul_one]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
a : G
l : List G
n : ℕ
hl : (take (n % (a :: l).length) (a :: l) ++ drop (n % (a :: l).length) (a :: l)).prod = 1
this : n % (a :: l).length ≤ (a :: l).length
⊢ ((a :: l).rotate n).prod = 1
state_after: no goals

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
a : G
l : List G
hl : (a :: l).prod = 1
n : ℕ
⊢ (a :: l).length > 0
state_after: no goals
Theorem: Finmap.union_assoc
File: Mathlib/Data/Finmap.lean

tactic: simp only [AList.toFinmap_eq, union_toFinmap, AList.union_assoc]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ s₃✝ : Finmap β
s₁ s₂ s₃ : AList β
⊢ ⟦s₁⟧ ∪ ⟦s₂⟧ ∪ ⟦s₃⟧ = ⟦s₁⟧ ∪ (⟦s₂⟧ ∪ ⟦s₃⟧)
state_after: no goals
Theorem: AhlswedeZhang.infSum_union_add_infSum_sups
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

tactic: unfold infSum
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ infSum (𝒜 ∪ ℬ) + infSum (𝒜 ⊻ ℬ) = infSum 𝒜 + infSum ℬ
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∑ s : Finset α, ↑((𝒜 ∪ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑((𝒜 ⊻ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) =
    ∑ s : Finset α, ↑(𝒜.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑(ℬ.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card))

tactic: rw [← sum_add_distrib, ← sum_add_distrib, sum_congr rfl fun s _ ↦ _]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∑ s : Finset α, ↑((𝒜 ∪ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑((𝒜 ⊻ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) =
    ∑ s : Finset α, ↑(𝒜.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
      ∑ s : Finset α, ↑(ℬ.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card))
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ,
    ↑((𝒜 ∪ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
        ↑((𝒜 ⊻ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) =
      ↑(𝒜.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
        ↑(ℬ.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card))

tactic: simp_rw [div_add_div_same, ← Nat.cast_add, card_truncatedInf_union_add_card_truncatedInf_sups]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ,
    ↑((𝒜 ∪ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
        ↑((𝒜 ⊻ ℬ).truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) =
      ↑(𝒜.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card)) +
        ↑(ℬ.truncatedInf s).card / (↑s.card * ↑((card α).choose s.card))
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ, True

tactic: simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
𝒜 ℬ : Finset (Finset α)
⊢ ∀ s ∈ univ, True
state_after: no goals
Theorem: CartanMatrix.Relations.adF_of_eq_eq_zero
File: Mathlib/Algebra/Lie/CartanMatrix.lean

tactic: have h' : (-2 : ℤ).toNat = 0 := rfl
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
⊢ adF R A (i, i) = 0
state_after: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : (-2).toNat = 0
⊢ adF R A (i, i) = 0

tactic: simp [adF, h, h']
state_before: R : Type u
B : Type v
inst✝² : CommRing R
inst✝¹ : DecidableEq B
inst✝ : Fintype B
A : Matrix B B ℤ
i : B
h : A i i = 2
h' : (-2).toNat = 0
⊢ adF R A (i, i) = 0
state_after: no goals
Theorem: rank_prod'
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: simp
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹¹ : Ring R
inst✝¹⁰ : CommRing S
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup M'
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R M
inst✝⁵ : Module R M'
inst✝⁴ : Module R M₁
inst✝³ : StrongRankCondition R
inst✝² : Module.Free R M
inst✝¹ : Module.Free R M'
inst✝ : Module.Free R M₁
⊢ Module.rank R (M × M₁) = Module.rank R M + Module.rank R M₁
state_after: no goals
Theorem: MvPolynomial.bind₁_comp_rename
File: Mathlib/Algebra/MvPolynomial/Monad.lean

tactic: ext1 i
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
υ : Type u_6
f : τ → MvPolynomial υ R
g : σ → τ
⊢ (bind₁ f).comp (rename g) = bind₁ (f ∘ g)
state_after: case hf
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
υ : Type u_6
f : τ → MvPolynomial υ R
g : σ → τ
i : σ
⊢ ((bind₁ f).comp (rename g)) (X i) = (bind₁ (f ∘ g)) (X i)

tactic: simp
state_before: case hf
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
υ : Type u_6
f : τ → MvPolynomial υ R
g : σ → τ
i : σ
⊢ ((bind₁ f).comp (rename g)) (X i) = (bind₁ (f ∘ g)) (X i)
state_after: no goals