1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.rootMultiplicity_mul_X_sub_C_pow
File: Mathlib/Algebra/Polynomial/RingDivision.lean

tactic: have h2 := monic_X_sub_C a |>.pow n |>.mul_left_ne_zero h
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) = rootMultiplicity a p + n
state_after: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) = rootMultiplicity a p + n

tactic: refine le_antisymm ?_ ?_
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) = rootMultiplicity a p + n
state_after: case refine_1
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) ≤ rootMultiplicity a p + n

case refine_2
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a p + n ≤ rootMultiplicity a (p * (X - C a) ^ n)

tactic: rw [rootMultiplicity_le_iff h2, add_assoc, add_comm n, ← add_assoc, pow_add,
  dvd_cancel_right_mem_nonZeroDivisors (monic_X_sub_C a |>.pow n |>.mem_nonZeroDivisors)]
state_before: case refine_1
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) ≤ rootMultiplicity a p + n
state_after: case refine_1
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ ¬(X - C a) ^ (rootMultiplicity a p + 1) ∣ p

tactic: exact pow_rootMultiplicity_not_dvd h a
state_before: case refine_1
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ ¬(X - C a) ^ (rootMultiplicity a p + 1) ∣ p
state_after: no goals

tactic: rw [le_rootMultiplicity_iff h2, pow_add]
state_before: case refine_2
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a p + n ≤ rootMultiplicity a (p * (X - C a) ^ n)
state_after: case refine_2
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ (X - C a) ^ rootMultiplicity a p * (X - C a) ^ n ∣ p * (X - C a) ^ n

tactic: exact mul_dvd_mul_right (pow_rootMultiplicity_dvd p a) _
state_before: case refine_2
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ (X - C a) ^ rootMultiplicity a p * (X - C a) ^ n ∣ p * (X - C a) ^ n
state_after: no goals
Theorem: Real.mul_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: iterate 2 rw [Real.rpow_def_of_nonneg]; split_ifs with h_ifs <;> simp_all
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ (x * y) ^ z = x ^ z * y ^ z
state_after: case neg
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs✝ : ¬y = 0
h_ifs : ¬x = 0
⊢ rexp (log (x * y) * z) = rexp (log x * z) * y ^ z

case neg.hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ 0 ≤ x

case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y

tactic: all_goals positivity
state_before: case neg.hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ 0 ≤ x

case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y
state_after: no goals

tactic: rw [Real.rpow_def_of_nonneg]
state_before: case neg
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ rexp (log (x * y) * z) = x ^ z * y ^ z

case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y
state_after: case neg
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ rexp (log (x * y) * z) = (if x = 0 then if z = 0 then 1 else 0 else rexp (log x * z)) * y ^ z

case neg.hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ 0 ≤ x

case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y

tactic: split_ifs with h_ifs <;> simp_all
state_before: case neg
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ rexp (log (x * y) * z) = (if x = 0 then if z = 0 then 1 else 0 else rexp (log x * z)) * y ^ z

case neg.hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ 0 ≤ x

case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y
state_after: case neg
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs✝ : ¬y = 0
h_ifs : ¬x = 0
⊢ rexp (log (x * y) * z) = rexp (log x * z) * y ^ z

case neg.hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs : ¬x = 0 ∧ ¬y = 0
⊢ 0 ≤ x

case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y

tactic: rw [log_mul ‹_› ‹_›, add_mul, exp_add, rpow_def_of_pos (hy.lt_of_ne' ‹_›)]
state_before: case neg
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
h_ifs✝ : ¬y = 0
h_ifs : ¬x = 0
⊢ rexp (log (x * y) * z) = rexp (log x * z) * y ^ z
state_after: no goals

tactic: positivity
state_before: case hx
x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
⊢ 0 ≤ x * y
state_after: no goals
Theorem: CommGrp.hasLimit_iff_small_sections
File: Mathlib/Algebra/Category/Grp/Limits.lean

tactic: constructor
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections
state_after: case mp
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ HasLimit F → Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections

case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections → HasLimit F

tactic: apply Concrete.small_sections_of_hasLimit
state_before: case mp
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ HasLimit F → Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections
state_after: no goals

tactic: intro
state_before: case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
⊢ Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections → HasLimit F
state_after: case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
a✝ : Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections
⊢ HasLimit F

tactic: infer_instance
state_before: case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ CommGrp
a✝ : Small.{u, max u v} ↑(F ⋙ forget CommGrp).sections
⊢ HasLimit F
state_after: no goals
Theorem: Ordinal.omega_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: let ⟨n, e⟩ := lt_omega.1 h
state_before: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
⊢ a < o
state_after: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ a < o

tactic: rw [e, ← succ_le_iff]
state_before: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ a < o
state_after: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ succ ↑n ≤ o

tactic: exact H (n + 1)
state_before: o : Ordinal.{u_1}
H : ∀ (n : ℕ), ↑n ≤ o
a : Ordinal.{u_1}
h : a < ω
n : ℕ
e : a = ↑n
⊢ succ ↑n ≤ o
state_after: no goals
Theorem: List.mem_keys_kerase_of_ne
File: Mathlib/Data/List/Sigma.lean

tactic: simpa [keys, h] using p
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : a₁ ≠ a₂
p✝ : a₁ ∈ l.keys
w✝² : β a₂
w✝¹ w✝ : List (Sigma β)
left✝ : a₂ ∉ w✝¹.keys
p : a₁ ∈ (w✝¹ ++ ⟨a₂, w✝²⟩ :: w✝).keys
q : a₂ ∈ (w✝¹ ++ ⟨a₂, w✝²⟩ :: w✝).keys
⊢ a₁ ∈ (w✝¹ ++ w✝).keys
state_after: no goals

tactic: simp [q, p]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : a₁ ≠ a₂
p : a₁ ∈ l.keys
q : a₂ ∉ l.keys
⊢ a₁ ∈ (kerase a₂ l).keys
state_after: no goals
Theorem: complementedLattice_iff_isAtomistic
File: Mathlib/Order/CompactlyGenerated/Basic.lean

tactic: constructor <;> intros
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : IsModularLattice α
inst✝ : IsCompactlyGenerated α
⊢ ComplementedLattice α ↔ IsAtomistic α
state_after: case mp
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : IsModularLattice α
inst✝ : IsCompactlyGenerated α
a✝ : ComplementedLattice α
⊢ IsAtomistic α

case mpr
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : IsModularLattice α
inst✝ : IsCompactlyGenerated α
a✝ : IsAtomistic α
⊢ ComplementedLattice α

tactic: exact isAtomistic_of_complementedLattice
state_before: case mp
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : IsModularLattice α
inst✝ : IsCompactlyGenerated α
a✝ : ComplementedLattice α
⊢ IsAtomistic α
state_after: no goals

tactic: exact complementedLattice_of_isAtomistic
state_before: case mpr
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : IsModularLattice α
inst✝ : IsCompactlyGenerated α
a✝ : IsAtomistic α
⊢ ComplementedLattice α
state_after: no goals
Theorem: IndexedPartition.iUnion
File: Mathlib/Data/Setoid/Partition.lean

tactic: ext x
state_before: ι : Type u_1
α : Type u_2
s : ι → Set α
hs : IndexedPartition s
⊢ ⋃ i, s i = univ
state_after: case h
ι : Type u_1
α : Type u_2
s : ι → Set α
hs : IndexedPartition s
x : α
⊢ x ∈ ⋃ i, s i ↔ x ∈ univ

tactic: simp [hs.exists_mem x]
state_before: case h
ι : Type u_1
α : Type u_2
s : ι → Set α
hs : IndexedPartition s
x : α
⊢ x ∈ ⋃ i, s i ↔ x ∈ univ
state_after: no goals
Theorem: PNat.card_Ico
File: Mathlib/Data/PNat/Interval.lean

tactic: rw [← Nat.card_Ico]
state_before: a b : ℕ+
⊢ (Ico a b).card = ↑b - ↑a
state_after: a b : ℕ+
⊢ (Ico a b).card = (Ico ↑a ↑b).card

tactic: erw [← Finset.map_subtype_embedding_Ico _ a b (fun c x _ hx _ hc _ => hc.trans_le hx)]
state_before: a b : ℕ+
⊢ (Ico a b).card = (Ico ↑a ↑b).card
state_after: a b : ℕ+
⊢ (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card

tactic: rw [card_map]
state_before: a b : ℕ+
⊢ (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card
state_after: no goals
Theorem: CliffordAlgebra.contractLeft_algebraMap_mul
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: rw [← Algebra.smul_def, map_smul, Algebra.smul_def]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
b : CliffordAlgebra Q
⊢ (contractLeft d) ((algebraMap R (CliffordAlgebra Q)) r * b) =
    (algebraMap R (CliffordAlgebra Q)) r * (contractLeft d) b
state_after: no goals
Theorem: smul_closedUnitBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [smul_closedBall _ _ zero_le_one, smul_zero, mul_one]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
⊢ c • closedBall 0 1 = closedBall 0 ‖c‖
state_after: no goals
Theorem: Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits
File: Mathlib/FieldTheory/Extension.lean

tactic: ext a
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
⊢ (Set.range fun ψ => ψ x) = (minpoly F x).rootSet L
state_after: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ a ∈ (minpoly F x).rootSet L

tactic: rw [mem_rootSet_of_ne (minpoly.ne_zero (Algebra.IsIntegral.isIntegral x))]
state_before: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ a ∈ (minpoly F x).rootSet L
state_after: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ (aeval a) (minpoly F x) = 0

tactic: refine ⟨fun ⟨ψ, hψ⟩ ↦ ?_, fun ha ↦ IntermediateField.exists_algHom_of_splits_of_aeval
  (fun x ↦ ⟨Algebra.IsIntegral.isIntegral x, hA x⟩) ha⟩
state_before: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ (aeval a) (minpoly F x) = 0
state_after: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
x✝ : a ∈ Set.range fun ψ => ψ x
ψ : K →ₐ[F] L
hψ : (fun ψ => ψ x) ψ = a
⊢ (aeval a) (minpoly F x) = 0

tactic: rw [← hψ, Polynomial.aeval_algHom_apply ψ x, minpoly.aeval, map_zero]
state_before: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
x✝ : a ∈ Set.range fun ψ => ψ x
ψ : K →ₐ[F] L
hψ : (fun ψ => ψ x) ψ = a
⊢ (aeval a) (minpoly F x) = 0
state_after: no goals
Theorem: Metric.exists_continuous_nnreal_forall_closedBall_subset
File: Mathlib/Topology/MetricSpace/PartitionOfUnity.lean

tactic: rcases EMetric.exists_continuous_nnreal_forall_closedBall_subset hK hU hKU hfin with ⟨δ, hδ0, hδ⟩
state_before: ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
⊢ ∃ δ, (∀ (x : X), 0 < δ x) ∧ ∀ (i : ι), ∀ x ∈ K i, closedBall x ↑(δ x) ⊆ U i
state_after: case intro.intro
ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < δ x
hδ : ∀ (i : ι), ∀ x ∈ K i, EMetric.closedBall x ↑(δ x) ⊆ U i
⊢ ∃ δ, (∀ (x : X), 0 < δ x) ∧ ∀ (i : ι), ∀ x ∈ K i, closedBall x ↑(δ x) ⊆ U i

tactic: refine ⟨δ, hδ0, fun i x hx => ?_⟩
state_before: case intro.intro
ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < δ x
hδ : ∀ (i : ι), ∀ x ∈ K i, EMetric.closedBall x ↑(δ x) ⊆ U i
⊢ ∃ δ, (∀ (x : X), 0 < δ x) ∧ ∀ (i : ι), ∀ x ∈ K i, closedBall x ↑(δ x) ⊆ U i
state_after: case intro.intro
ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < δ x
hδ : ∀ (i : ι), ∀ x ∈ K i, EMetric.closedBall x ↑(δ x) ⊆ U i
i : ι
x : X
hx : x ∈ K i
⊢ closedBall x ↑(δ x) ⊆ U i

tactic: rw [← emetric_closedBall_nnreal]
state_before: case intro.intro
ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < δ x
hδ : ∀ (i : ι), ∀ x ∈ K i, EMetric.closedBall x ↑(δ x) ⊆ U i
i : ι
x : X
hx : x ∈ K i
⊢ closedBall x ↑(δ x) ⊆ U i
state_after: case intro.intro
ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < δ x
hδ : ∀ (i : ι), ∀ x ∈ K i, EMetric.closedBall x ↑(δ x) ⊆ U i
i : ι
x : X
hx : x ∈ K i
⊢ EMetric.closedBall x ↑(δ x) ⊆ U i

tactic: exact hδ i x hx
state_before: case intro.intro
ι : Type u_1
X : Type u_2
inst✝ : MetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ0 : ∀ (x : X), 0 < δ x
hδ : ∀ (i : ι), ∀ x ∈ K i, EMetric.closedBall x ↑(δ x) ⊆ U i
i : ι
x : X
hx : x ∈ K i
⊢ EMetric.closedBall x ↑(δ x) ⊆ U i
state_after: no goals
Theorem: HasProd.update
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: convert (hasProd_ite_eq b (a / f b)).mul hf with b'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
⊢ HasProd (Function.update f b a) (a / f b * a₁)
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'

tactic: by_cases h : b' = b
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : ¬b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'

tactic: rw [h, update_same]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : b' = b
⊢ a = (if b = b then a / f b else 1) * f b

tactic: simp [eq_self_iff_true, if_true, sub_add_cancel]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : b' = b
⊢ a = (if b = b then a / f b else 1) * f b
state_after: no goals

tactic: simp only [h, update_noteq, if_false, Ne, one_mul, not_false_iff]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : ¬b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
state_after: no goals
Theorem: MonoidWithZeroHom.cancel_left
File: Mathlib/Algebra/GroupWithZero/Hom.lean

tactic: rw [← comp_apply, h,
comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
M₀ : Type u_6
inst✝⁴ : MulZeroOneClass α
inst✝³ : MulZeroOneClass β
inst✝² : MulZeroOneClass γ
inst✝¹ : MulZeroOneClass δ
inst✝ : FunLike F α β
g : β →*₀ γ
f₁ f₂ : α →*₀ β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
x : α
⊢ g (f₁ x) = g (f₂ x)
state_after: no goals
Theorem: Nat.nth_lt_of_lt_count
File: Mathlib/Data/Nat/Nth.lean

tactic: refine (count_monotone p).reflect_lt ?_
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ nth p k < n
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ count p (nth p k) < count p n

tactic: rwa [count_nth]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ count p (nth p k) < count p n
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ ∀ (hf : (setOf p).Finite), k < hf.toFinset.card

tactic: exact fun hf => h.trans_le (count_le_card hf n)
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ ∀ (hf : (setOf p).Finite), k < hf.toFinset.card
state_after: no goals
Theorem: Pretrivialization.proj_symm_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: have := (e.coe_fst (e.map_target hx)).symm
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
⊢ proj (↑e.symm x) = x.1
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
this : proj (↑e.symm x) = (↑e (↑e.symm x)).1
⊢ proj (↑e.symm x) = x.1

tactic: rwa [← e.coe_coe, e.right_inv hx] at this
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
this : proj (↑e.symm x) = (↑e (↑e.symm x)).1
⊢ proj (↑e.symm x) = x.1
state_after: no goals
Theorem: Filter.frequently_lt_of_lt_limsSup
File: Mathlib/Order/LiminfLimsup.lean

tactic: contrapose! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : a < f.limsSup
⊢ ∃ᶠ (n : α) in f, a < n
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ¬∃ᶠ (n : α) in f, a < n
⊢ f.limsSup ≤ a

tactic: simp only [not_frequently, not_lt] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ¬∃ᶠ (n : α) in f, a < n
⊢ f.limsSup ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ∀ᶠ (x : α) in f, x ≤ a
⊢ f.limsSup ≤ a

tactic: exact limsSup_le_of_le hf h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ∀ᶠ (x : α) in f, x ≤ a
⊢ f.limsSup ≤ a
state_after: no goals