1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Cardinal.card_biUnion_lt_iff_forall_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [biUnion_eq_iUnion, card_iUnion_lt_iff_forall_of_isRegular hc hs, SetCoe.forall']
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
α β : Type u
s : Set α
t : (a : α) → a ∈ s → Set β
c : Cardinal.{u}
hc : c.IsRegular
hs : #↑s < c
⊢ #↑(⋃ a, ⋃ (h : a ∈ s), t a h) < c ↔ ∀ (a : α) (ha : a ∈ s), #↑(t a ha) < c
state_after: no goals
Theorem: geom_sum_succ
File: Mathlib/Algebra/GeomSum.lean

tactic: simp only [mul_sum, ← pow_succ', sum_range_succ', pow_zero]
state_before: α : Type u
inst✝ : Semiring α
x : α
n : ℕ
⊢ ∑ i ∈ range (n + 1), x ^ i = x * ∑ i ∈ range n, x ^ i + 1
state_after: no goals
Theorem: MeasureTheory.setIntegral_mono_on_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: refine setIntegral_mono_ae_restrict hf hg ?_
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f g : X → ℝ
s t : Set X
hf : IntegrableOn f s μ
hg : IntegrableOn g s μ
hs : MeasurableSet s
h : ∀ᵐ (x : X) ∂μ, x ∈ s → f x ≤ g x
⊢ ∫ (x : X) in s, f x ∂μ ≤ ∫ (x : X) in s, g x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f g : X → ℝ
s t : Set X
hf : IntegrableOn f s μ
hg : IntegrableOn g s μ
hs : MeasurableSet s
h : ∀ᵐ (x : X) ∂μ, x ∈ s → f x ≤ g x
⊢ f ≤ᶠ[ae (μ.restrict s)] g

tactic: rwa [EventuallyLE, ae_restrict_iff' hs]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝ : MeasurableSpace X
μ : Measure X
f g : X → ℝ
s t : Set X
hf : IntegrableOn f s μ
hg : IntegrableOn g s μ
hs : MeasurableSet s
h : ∀ᵐ (x : X) ∂μ, x ∈ s → f x ≤ g x
⊢ f ≤ᶠ[ae (μ.restrict s)] g
state_after: no goals
Theorem: IsSigmaCompact.isLindelof
File: Mathlib/Topology/Compactness/Lindelof.lean

tactic: rw [IsSigmaCompact] at hs
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : IsSigmaCompact s
⊢ IsLindelof s
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : ∃ K, (∀ (n : ℕ), IsCompact (K n)) ∧ ⋃ n, K n = s
⊢ IsLindelof s

tactic: rcases hs with ⟨K, ⟨hc, huniv⟩⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
hs : ∃ K, (∀ (n : ℕ), IsCompact (K n)) ∧ ⋃ n, K n = s
⊢ IsLindelof s
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
K : ℕ → Set X
hc : ∀ (n : ℕ), IsCompact (K n)
huniv : ⋃ n, K n = s
⊢ IsLindelof s

tactic: rw [← huniv]
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
K : ℕ → Set X
hc : ∀ (n : ℕ), IsCompact (K n)
huniv : ⋃ n, K n = s
⊢ IsLindelof s
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
K : ℕ → Set X
hc : ∀ (n : ℕ), IsCompact (K n)
huniv : ⋃ n, K n = s
⊢ IsLindelof (⋃ n, K n)

tactic: have hl : ∀ n, IsLindelof (K n) := fun n ↦ IsCompact.isLindelof (hc n)
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
K : ℕ → Set X
hc : ∀ (n : ℕ), IsCompact (K n)
huniv : ⋃ n, K n = s
⊢ IsLindelof (⋃ n, K n)
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
K : ℕ → Set X
hc : ∀ (n : ℕ), IsCompact (K n)
huniv : ⋃ n, K n = s
hl : ∀ (n : ℕ), IsLindelof (K n)
⊢ IsLindelof (⋃ n, K n)

tactic: exact isLindelof_iUnion hl
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
K : ℕ → Set X
hc : ∀ (n : ℕ), IsCompact (K n)
huniv : ⋃ n, K n = s
hl : ∀ (n : ℕ), IsLindelof (K n)
⊢ IsLindelof (⋃ n, K n)
state_after: no goals
Theorem: inv_mabs_le
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: obtain h | h := le_total 1 a
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ (mabs a)⁻¹ ≤ a
state_after: case inl
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
h : 1 ≤ a
⊢ (mabs a)⁻¹ ≤ a

case inr
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
h : a ≤ 1
⊢ (mabs a)⁻¹ ≤ a

tactic: simpa [mabs_of_one_le h] using (inv_le_one'.2 h).trans h
state_before: case inl
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
h : 1 ≤ a
⊢ (mabs a)⁻¹ ≤ a
state_after: no goals

tactic: simp [mabs_of_le_one h]
state_before: case inr
α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
a✝¹ b✝ : α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
h : a ≤ 1
⊢ (mabs a)⁻¹ ≤ a
state_after: no goals
Theorem: DFinsupp.support_filter
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
⊢ (filter p f).support = Finset.filter p f.support
state_after: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ i ∈ (filter p f).support ↔ i ∈ Finset.filter p f.support

tactic: by_cases h : p i <;> simp [h]
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : ι
⊢ i ∈ (filter p f).support ↔ i ∈ Finset.filter p f.support
state_after: no goals
Theorem: Polynomial.support_C_mul_X_pow
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [C_mul_X_pow_eq_monomial, support_monomial n h]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
c : R
h : c ≠ 0
⊢ (C c * X ^ n).support = {n}
state_after: no goals
Theorem: Fintype.range_total
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [← Finsupp.total_eq_fintype_total, LinearMap.range_comp, LinearEquiv.range,
  Submodule.map_top, Finsupp.range_total]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝⁶ : Fintype α
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_4
inst✝² : Semiring S
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
v : α → M
⊢ LinearMap.range ((Fintype.total R S) v) = span R (Set.range v)
state_after: no goals
Theorem: Setoid.eqvGen_le
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [eqvGen_eq]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
s : Setoid α
h : ∀ (x y : α), r x y → s.Rel x y
⊢ EqvGen.Setoid r ≤ s
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
s : Setoid α
h : ∀ (x y : α), r x y → s.Rel x y
⊢ sInf {s | ∀ ⦃x y : α⦄, r x y → s.Rel x y} ≤ s

tactic: exact sInf_le h
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
s : Setoid α
h : ∀ (x y : α), r x y → s.Rel x y
⊢ sInf {s | ∀ ⦃x y : α⦄, r x y → s.Rel x y} ≤ s
state_after: no goals
Theorem: Finset.truncatedInf_union_right
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

tactic: rw [union_comm, truncatedInf_union_left ht hs]
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : SemilatticeInf α
inst✝⁵ : BoundedOrder α
inst✝⁴ : DecidableRel fun x x_1 => x ≤ x_1
inst✝³ : SemilatticeInf β
inst✝² : BoundedOrder β
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
inst✝ : DecidableEq α
hs : a ∉ upperClosure ↑s
ht : a ∈ upperClosure ↑t
⊢ (s ∪ t).truncatedInf a = t.truncatedInf a
state_after: no goals
Theorem: Real.summable_abs_int_rpow
File: Mathlib/Analysis/PSeries.lean

tactic: apply Summable.of_nat_of_neg
state_before: b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑n| ^ (-b)
state_after: case hf₁
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)

case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑(-↑n)| ^ (-b)

tactic: on_goal 2 => simp_rw [Int.cast_neg, abs_neg]
state_before: case hf₁
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)

case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑(-↑n)| ^ (-b)
state_after: case hf₁
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)

case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)

tactic: all_goals
  simp_rw [Int.cast_natCast, fun n : ℕ => abs_of_nonneg (n.cast_nonneg : 0 ≤ (n : ℝ))]
  rwa [summable_nat_rpow, neg_lt_neg_iff]
state_before: case hf₁
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)

case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)
state_after: no goals

tactic: simp_rw [Int.cast_neg, abs_neg]
state_before: case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑(-↑n)| ^ (-b)
state_after: case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)

tactic: simp_rw [Int.cast_natCast, fun n : ℕ => abs_of_nonneg (n.cast_nonneg : 0 ≤ (n : ℝ))]
state_before: case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => |↑↑n| ^ (-b)
state_after: case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => ↑n ^ (-b)

tactic: rwa [summable_nat_rpow, neg_lt_neg_iff]
state_before: case hf₂
b : ℝ
hb : 1 < b
⊢ Summable fun n => ↑n ^ (-b)
state_after: no goals
Theorem: Zsqrtd.norm_eq_one_iff_mem_unitary
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [unitary.mem_iff_self_mul_star, ← norm_eq_mul_conj]
state_before: R : Type
inst✝ : CommRing R
d : ℤ
a : ℤ√d
⊢ a.norm = 1 ↔ a ∈ unitary (ℤ√d)
state_after: R : Type
inst✝ : CommRing R
d : ℤ
a : ℤ√d
⊢ a.norm = 1 ↔ ↑a.norm = 1

tactic: norm_cast
state_before: R : Type
inst✝ : CommRing R
d : ℤ
a : ℤ√d
⊢ a.norm = 1 ↔ ↑a.norm = 1
state_after: no goals
Theorem: ENNReal.ofReal_sum_of_nonneg
File: Mathlib/Data/ENNReal/Operations.lean

tactic: simp_rw [ENNReal.ofReal, ← coe_finset_sum, coe_inj]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ i ∈ s, 0 ≤ f i
⊢ ENNReal.ofReal (∑ i ∈ s, f i) = ∑ i ∈ s, ENNReal.ofReal (f i)
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ i ∈ s, 0 ≤ f i
⊢ (∑ i ∈ s, f i).toNNReal = ∑ a ∈ s, (f a).toNNReal

tactic: exact Real.toNNReal_sum_of_nonneg hf
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ i ∈ s, 0 ≤ f i
⊢ (∑ i ∈ s, f i).toNNReal = ∑ a ∈ s, (f a).toNNReal
state_after: no goals
Theorem: WeierstrassCurve.Projective.smul_fin3
File: Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean

tactic: rw [fin3_def P]
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
W : Projective R✝
R : Type u
inst✝ : CommRing R
P : Fin 3 → R
u : Rˣ
⊢ u • P = ![↑u * P 0, ↑u * P 1, ↑u * P 2]
state_after: R✝ : Type u
inst✝¹ : CommRing R✝
W : Projective R✝
R : Type u
inst✝ : CommRing R
P : Fin 3 → R
u : Rˣ
⊢ u • ![P 0, P 1, P 2] = ![↑u * ![P 0, P 1, P 2] 0, ↑u * ![P 0, P 1, P 2] 1, ↑u * ![P 0, P 1, P 2] 2]

tactic: matrix_simp
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
W : Projective R✝
R : Type u
inst✝ : CommRing R
P : Fin 3 → R
u : Rˣ
⊢ u • ![P 0, P 1, P 2] = ![↑u * ![P 0, P 1, P 2] 0, ↑u * ![P 0, P 1, P 2] 1, ↑u * ![P 0, P 1, P 2] 2]
state_after: R✝ : Type u
inst✝¹ : CommRing R✝
W : Projective R✝
R : Type u
inst✝ : CommRing R
P : Fin 3 → R
u : Rˣ
⊢ ![u • P 0, u • P 1, u • P 2] = ![↑u * P 0, ↑u * P 1, ↑u * P 2]

tactic: simp only [Units.smul_def, smul_eq_mul]
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
W : Projective R✝
R : Type u
inst✝ : CommRing R
P : Fin 3 → R
u : Rˣ
⊢ ![u • P 0, u • P 1, u • P 2] = ![↑u * P 0, ↑u * P 1, ↑u * P 2]
state_after: no goals
Theorem: Primrec.of_equiv_symm
File: Mathlib/Computability/Primrec.lean

tactic: simp [Primrec.encode]
state_before: α : Type u_1
β✝ : Type u_2
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β✝
inst✝ : Primcodable σ
β : Type u_4
e : β ≃ α
this : Primcodable β := Primcodable.ofEquiv α e
⊢ Primrec fun a => encode (e (e.symm a))
state_after: no goals
Theorem: Set.mulIndicator_mulIndicator
File: Mathlib/Algebra/Group/Indicator.lean

tactic: simp only [mulIndicator]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s t : Set α
f : α → M
x : α
⊢ s.mulIndicator (t.mulIndicator f) x = (s ∩ t).mulIndicator f x
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s t : Set α
f : α → M
x : α
⊢ (if x ∈ s then if x ∈ t then f x else 1 else 1) = if x ∈ s ∩ t then f x else 1

tactic: split_ifs <;> simp_all (config := { contextual := true })
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s t : Set α
f : α → M
x : α
⊢ (if x ∈ s then if x ∈ t then f x else 1 else 1) = if x ∈ s ∩ t then f x else 1
state_after: no goals
Theorem: Option.map₂_eq_none_iff
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
⊢ map₂ f a b = none ↔ a = none ∨ b = none
state_after: no goals
Theorem: ContextFreeRule.rewrites_iff
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: rintro ⟨p, q, rfl, rfl⟩
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
⊢ (∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q) → r.Rewrites u v
state_after: case intro.intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
p q : List (Symbol T N)
⊢ r.Rewrites (p ++ [Symbol.nonterminal r.input] ++ q) (p ++ r.output ++ q)

tactic: apply rewrites_of_exists_parts
state_before: case intro.intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
p q : List (Symbol T N)
⊢ r.Rewrites (p ++ [Symbol.nonterminal r.input] ++ q) (p ++ r.output ++ q)
state_after: no goals
Theorem: NumberField.Units.dirichletUnitTheorem.mult_log_place_eq_zero
File: Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean

tactic: rw [mul_eq_zero, or_iff_right, Real.log_eq_zero, or_iff_right, or_iff_left]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ↑w.mult * Real.log (w ((algebraMap (𝓞 K) K) ↑x)) = 0 ↔ w ((algebraMap (𝓞 K) K) ↑x) = 1
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬w ((algebraMap (𝓞 K) K) ↑x) = -1

K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬w ((algebraMap (𝓞 K) K) ↑x) = 0

K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬↑w.mult = 0

tactic: linarith [(apply_nonneg _ _ : 0 ≤ w x)]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬w ((algebraMap (𝓞 K) K) ↑x) = -1
state_after: no goals

tactic: simp only [ne_eq, map_eq_zero, coe_ne_zero x, not_false_eq_true]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬w ((algebraMap (𝓞 K) K) ↑x) = 0
state_after: no goals

tactic: refine (ne_of_gt ?_)
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ ¬↑w.mult = 0
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ 0 < ↑w.mult

tactic: rw [mult]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ 0 < ↑w.mult
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ 0 < ↑(if w.IsReal then 1 else 2)

tactic: split_ifs <;> norm_num
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
x : (𝓞 K)ˣ
w : InfinitePlace K
⊢ 0 < ↑(if w.IsReal then 1 else 2)
state_after: no goals
Theorem: NonUnitalNonAssocCommSemiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

tactic: rintro rfl
state_before: R : Type u
inst₁ inst₂ : NonUnitalNonAssocCommSemiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonUnitalNonAssocCommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul

tactic: constructor <;> rfl
state_before: R : Type u
inst₁ : NonUnitalNonAssocCommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
Theorem: List.NodupKeys.eq_of_mk_mem
File: Mathlib/Data/List/Sigma.lean

tactic: cases nd.eq_of_fst_eq h h' rfl
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
a : α
b b' : β a
l : List (Sigma β)
nd : l.NodupKeys
h : ⟨a, b⟩ ∈ l
h' : ⟨a, b'⟩ ∈ l
⊢ b = b'
state_after: case refl
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
a : α
b : β a
l : List (Sigma β)
nd : l.NodupKeys
h h' : ⟨a, b⟩ ∈ l
⊢ b = b

tactic: rfl
state_before: case refl
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
a : α
b : β a
l : List (Sigma β)
nd : l.NodupKeys
h h' : ⟨a, b⟩ ∈ l
⊢ b = b
state_after: no goals
Theorem: Polynomial.as_sum_support_C_mul_X_pow
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simp only [C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ ∑ i ∈ p.support, (monomial i) (p.coeff i) = ∑ i ∈ p.support, C (p.coeff i) * X ^ i
state_after: no goals
Theorem: Finset.image₂_subset_iff_left
File: Mathlib/Data/Finset/NAry.lean

tactic: simp_rw [image₂_subset_iff, image_subset_iff]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ image₂ f s t ⊆ u ↔ ∀ a ∈ s, image (fun b => f a b) t ⊆ u
state_after: no goals
Theorem: Filter.comap_pure
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← principal_singleton, comap_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
b : β
⊢ comap m (pure b) = 𝓟 (m ⁻¹' {b})
state_after: no goals
Theorem: triple_product_eq_det
File: Mathlib/LinearAlgebra/CrossProduct.lean

tactic: rw [vec3_dotProduct, cross_apply, det_fin_three]
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u ⬝ᵥ (crossProduct v) w = det ![u, v, w]
state_after: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * ![v 1 * w 2 - v 2 * w 1, v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 0 +
        u 1 * ![v 1 * w 2 - v 2 * w 1, v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 1 +
      u 2 * ![v 1 * w 2 - v 2 * w 1, v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 2 =
    ![u, v, w] 0 0 * ![u, v, w] 1 1 * ![u, v, w] 2 2 - ![u, v, w] 0 0 * ![u, v, w] 1 2 * ![u, v, w] 2 1 -
            ![u, v, w] 0 1 * ![u, v, w] 1 0 * ![u, v, w] 2 2 +
          ![u, v, w] 0 1 * ![u, v, w] 1 2 * ![u, v, w] 2 0 +
        ![u, v, w] 0 2 * ![u, v, w] 1 0 * ![u, v, w] 2 1 -
      ![u, v, w] 0 2 * ![u, v, w] 1 1 * ![u, v, w] 2 0

tactic: norm_num
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * ![v 1 * w 2 - v 2 * w 1, v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 0 +
        u 1 * ![v 1 * w 2 - v 2 * w 1, v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 1 +
      u 2 * ![v 1 * w 2 - v 2 * w 1, v 2 * w 0 - v 0 * w 2, v 0 * w 1 - v 1 * w 0] 2 =
    ![u, v, w] 0 0 * ![u, v, w] 1 1 * ![u, v, w] 2 2 - ![u, v, w] 0 0 * ![u, v, w] 1 2 * ![u, v, w] 2 1 -
            ![u, v, w] 0 1 * ![u, v, w] 1 0 * ![u, v, w] 2 2 +
          ![u, v, w] 0 1 * ![u, v, w] 1 2 * ![u, v, w] 2 0 +
        ![u, v, w] 0 2 * ![u, v, w] 1 0 * ![u, v, w] 2 1 -
      ![u, v, w] 0 2 * ![u, v, w] 1 1 * ![u, v, w] 2 0
state_after: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * (v 1 * w 2 - v 2 * w 1) + u 1 * (v 2 * w 0 - v 0 * w 2) + u 2 * (v 0 * w 1 - v 1 * w 0) =
    u 0 * v 1 * w 2 - u 0 * v 2 * w 1 - u 1 * v 0 * w 2 + u 1 * v 2 * w 0 + u 2 * v 0 * w 1 - u 2 * v 1 * w 0

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
u v w : Fin 3 → R
⊢ u 0 * (v 1 * w 2 - v 2 * w 1) + u 1 * (v 2 * w 0 - v 0 * w 2) + u 2 * (v 0 * w 1 - v 1 * w 0) =
    u 0 * v 1 * w 2 - u 0 * v 2 * w 1 - u 1 * v 0 * w 2 + u 1 * v 2 * w 0 + u 2 * v 0 * w 1 - u 2 * v 1 * w 0
state_after: no goals
Theorem: CategoryTheory.lift_comp_preservesLimitsIso_hom
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: ext
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝² : Category.{w', w} J
F : J ⥤ C
inst✝¹ : PreservesLimit F G
inst✝ : HasLimit F
t : Cone F
⊢ G.map (limit.lift F t) ≫ (preservesLimitIso G F).hom = limit.lift (F ⋙ G) (G.mapCone t)
state_after: case w
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝² : Category.{w', w} J
F : J ⥤ C
inst✝¹ : PreservesLimit F G
inst✝ : HasLimit F
t : Cone F
j✝ : J
⊢ (G.map (limit.lift F t) ≫ (preservesLimitIso G F).hom) ≫ limit.π (F ⋙ G) j✝ =
    limit.lift (F ⋙ G) (G.mapCone t) ≫ limit.π (F ⋙ G) j✝

tactic: simp [← G.map_comp]
state_before: case w
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝² : Category.{w', w} J
F : J ⥤ C
inst✝¹ : PreservesLimit F G
inst✝ : HasLimit F
t : Cone F
j✝ : J
⊢ (G.map (limit.lift F t) ≫ (preservesLimitIso G F).hom) ≫ limit.π (F ⋙ G) j✝ =
    limit.lift (F ⋙ G) (G.mapCone t) ≫ limit.π (F ⋙ G) j✝
state_after: no goals
Theorem: Quaternion.exp_of_re_eq_zero
File: Mathlib/Analysis/NormedSpace/QuaternionExponential.lean

tactic: rw [exp_eq_tsum]
state_before: q : ℍ
hq : q.re = 0
⊢ exp ℝ q = ↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q
state_after: q : ℍ
hq : q.re = 0
⊢ (fun x => ∑' (n : ℕ), (↑n !)⁻¹ • x ^ n) q = ↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q

tactic: refine HasSum.tsum_eq ?_
state_before: q : ℍ
hq : q.re = 0
⊢ (fun x => ∑' (n : ℕ), (↑n !)⁻¹ • x ^ n) q = ↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q
state_after: q : ℍ
hq : q.re = 0
⊢ HasSum (fun n => (↑n !)⁻¹ • q ^ n) (↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q)

tactic: simp_rw [← expSeries_apply_eq]
state_before: q : ℍ
hq : q.re = 0
⊢ HasSum (fun n => (↑n !)⁻¹ • q ^ n) (↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q)
state_after: q : ℍ
hq : q.re = 0
⊢ HasSum (fun n => (expSeries ℝ ℍ n) fun x => q) (↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q)

tactic: exact hasSum_expSeries_of_imaginary hq (Real.hasSum_cos _) (Real.hasSum_sin _)
state_before: q : ℍ
hq : q.re = 0
⊢ HasSum (fun n => (expSeries ℝ ℍ n) fun x => q) (↑(Real.cos ‖q‖) + (Real.sin ‖q‖ / ‖q‖) • q)
state_after: no goals
Theorem: List.nodup_sublistsLen
File: Mathlib/Data/List/Sublists.lean

tactic: exact this.sublist (sublistsLen_sublist_sublists' _ _)
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h : l.Nodup
this : Pairwise (fun x x_1 => x ≠ x_1) l.sublists'
⊢ (sublistsLen n l).Nodup
state_after: no goals

tactic: convert h using 3
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h✝ : l.Nodup
a✝ b✝ : List α
h : Lex (swap fun x x_1 => x ≠ x_1) a✝ b✝
⊢ Lex (fun x x_1 => x ≠ x_1) a✝ b✝
state_after: case h.e'_2.h.e'_4.h.h
α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h✝ : l.Nodup
a✝ b✝ : List α
h : Lex (swap fun x x_1 => x ≠ x_1) a✝ b✝
x✝ : α
⊢ (fun x => ¬x = x✝) = fun x => x✝ ≠ x

tactic: simp [swap, eq_comm]
state_before: case h.e'_2.h.e'_4.h.h
α : Type u
β : Type v
γ : Type w
n : ℕ
l : List α
h✝ : l.Nodup
a✝ b✝ : List α
h : Lex (swap fun x x_1 => x ≠ x_1) a✝ b✝
x✝ : α
⊢ (fun x => ¬x = x✝) = fun x => x✝ ≠ x
state_after: no goals