1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Primrec₂.ofNat_iff
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α✝ : Type u_1
β✝ : Type u_2
σ✝ : Type u_3
inst✝⁵ : Primcodable α✝
inst✝⁴ : Primcodable β✝
inst✝³ : Primcodable σ✝
α : Type u_4
β : Type u_5
σ : Type u_6
inst✝² : Denumerable α
inst✝¹ : Denumerable β
inst✝ : Primcodable σ
f : α → β → σ
⊢ (Primrec fun n => f (ofNat (α × β) n).1 (ofNat (α × β) n).2) ↔
    Primrec (Nat.unpaired fun m n => f (ofNat α m) (ofNat β n))
state_after: no goals
Theorem: IsComplete.union
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp only [isComplete_iff_ultrafilter', Ultrafilter.union_mem_iff, or_imp] at *
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
s t : Set α
hs : IsComplete s
ht : IsComplete t
⊢ IsComplete (s ∪ t)
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
s t : Set α
hs : ∀ (l : Ultrafilter α), Cauchy ↑l → s ∈ l → ∃ x ∈ s, ↑l ≤ 𝓝 x
ht : ∀ (l : Ultrafilter α), Cauchy ↑l → t ∈ l → ∃ x ∈ t, ↑l ≤ 𝓝 x
⊢ ∀ (l : Ultrafilter α), Cauchy ↑l → (s ∈ l → ∃ x ∈ s ∪ t, ↑l ≤ 𝓝 x) ∧ (t ∈ l → ∃ x ∈ s ∪ t, ↑l ≤ 𝓝 x)

tactic: exact fun l hl =>
  ⟨fun hsl => (hs l hl hsl).imp fun x hx => ⟨Or.inl hx.1, hx.2⟩, fun htl =>
    (ht l hl htl).imp fun x hx => ⟨Or.inr hx.1, hx.2⟩⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
s t : Set α
hs : ∀ (l : Ultrafilter α), Cauchy ↑l → s ∈ l → ∃ x ∈ s, ↑l ≤ 𝓝 x
ht : ∀ (l : Ultrafilter α), Cauchy ↑l → t ∈ l → ∃ x ∈ t, ↑l ≤ 𝓝 x
⊢ ∀ (l : Ultrafilter α), Cauchy ↑l → (s ∈ l → ∃ x ∈ s ∪ t, ↑l ≤ 𝓝 x) ∧ (t ∈ l → ∃ x ∈ s ∪ t, ↑l ≤ 𝓝 x)
state_after: no goals
Theorem: SmoothPartitionOfUnity.contDiffAt_finsum
File: Mathlib/Geometry/Manifold/PartitionOfUnity.lean

tactic: simp only [← contMDiffAt_iff_contDiffAt] at *
state_before: ι : Type uι
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
s✝ : Set M
f✝ : SmoothPartitionOfUnity ι I M s✝
n : ℕ∞
s : Set E
f : SmoothPartitionOfUnity ι 𝓘(ℝ, E) E s
x₀ : E
g : ι → E → F
hφ : ∀ (i : ι), x₀ ∈ tsupport ⇑(f i) → ContDiffAt ℝ n (g i) x₀
⊢ ContDiffAt ℝ n (fun x => ∑ᶠ (i : ι), (f i) x • g i x) x₀
state_after: ι : Type uι
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
s✝ : Set M
f✝ : SmoothPartitionOfUnity ι I M s✝
n : ℕ∞
s : Set E
f : SmoothPartitionOfUnity ι 𝓘(ℝ, E) E s
x₀ : E
g : ι → E → F
hφ : ∀ (i : ι), x₀ ∈ tsupport ⇑(f i) → ContMDiffAt 𝓘(ℝ, E) 𝓘(ℝ, F) n (g i) x₀
⊢ ContMDiffAt 𝓘(ℝ, E) 𝓘(ℝ, F) n (fun x => ∑ᶠ (i : ι), (f i) x • g i x) x₀

tactic: exact f.contMDiffAt_finsum hφ
state_before: ι : Type uι
E : Type uE
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
s✝ : Set M
f✝ : SmoothPartitionOfUnity ι I M s✝
n : ℕ∞
s : Set E
f : SmoothPartitionOfUnity ι 𝓘(ℝ, E) E s
x₀ : E
g : ι → E → F
hφ : ∀ (i : ι), x₀ ∈ tsupport ⇑(f i) → ContMDiffAt 𝓘(ℝ, E) 𝓘(ℝ, F) n (g i) x₀
⊢ ContMDiffAt 𝓘(ℝ, E) 𝓘(ℝ, F) n (fun x => ∑ᶠ (i : ι), (f i) x • g i x) x₀
state_after: no goals
Theorem: List.reduceOption_concat
File: Mathlib/Data/List/ReduceOption.lean

tactic: induction' l with hd tl hl generalizing x
state_before: α : Type u_1
β : Type u_2
l : List (Option α)
x : Option α
⊢ (l.concat x).reduceOption = l.reduceOption ++ x.toList
state_after: case nil
α : Type u_1
β : Type u_2
x : Option α
⊢ ([].concat x).reduceOption = [].reduceOption ++ x.toList

case cons
α : Type u_1
β : Type u_2
hd : Option α
tl : List (Option α)
hl : ∀ (x : Option α), (tl.concat x).reduceOption = tl.reduceOption ++ x.toList
x : Option α
⊢ ((hd :: tl).concat x).reduceOption = (hd :: tl).reduceOption ++ x.toList

tactic: cases x <;> simp [Option.toList]
state_before: case nil
α : Type u_1
β : Type u_2
x : Option α
⊢ ([].concat x).reduceOption = [].reduceOption ++ x.toList
state_after: no goals

tactic: simp only [concat_eq_append, reduceOption_append] at hl
state_before: case cons
α : Type u_1
β : Type u_2
hd : Option α
tl : List (Option α)
hl : ∀ (x : Option α), (tl.concat x).reduceOption = tl.reduceOption ++ x.toList
x : Option α
⊢ ((hd :: tl).concat x).reduceOption = (hd :: tl).reduceOption ++ x.toList
state_after: case cons
α : Type u_1
β : Type u_2
hd : Option α
tl : List (Option α)
x : Option α
hl : ∀ (x : Option α), tl.reduceOption ++ [x].reduceOption = tl.reduceOption ++ x.toList
⊢ ((hd :: tl).concat x).reduceOption = (hd :: tl).reduceOption ++ x.toList

tactic: cases hd <;> simp [hl, reduceOption_append]
state_before: case cons
α : Type u_1
β : Type u_2
hd : Option α
tl : List (Option α)
x : Option α
hl : ∀ (x : Option α), tl.reduceOption ++ [x].reduceOption = tl.reduceOption ++ x.toList
⊢ ((hd :: tl).concat x).reduceOption = (hd :: tl).reduceOption ++ x.toList
state_after: no goals
Theorem: Representation.asAlgebraHom_of
File: Mathlib/RepresentationTheory/Basic.lean

tactic: simp only [MonoidAlgebra.of_apply, asAlgebraHom_single, one_smul]
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
⊢ ρ.asAlgebraHom ((of k G) g) = ρ g
state_after: no goals
Theorem: uniformConcaveOn_zero
File: Mathlib/Analysis/Convex/Strong.lean

tactic: simp [UniformConcaveOn, ConcaveOn]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
⊢ UniformConcaveOn s 0 f ↔ ConcaveOn ℝ s f
state_after: no goals
Theorem: Subalgebra.finrank_sup_eq_finrank_right_mul_finrank_of_free
File: Mathlib/Algebra/Algebra/Subalgebra/Rank.lean

tactic: rw [sup_comm, finrank_sup_eq_finrank_left_mul_finrank_of_free]
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
A B : Subalgebra R S
inst✝³ : Module.Free R ↥A
inst✝² : Module.Free R ↥B
inst✝¹ : Module.Free ↥A ↥(Algebra.adjoin ↥A ↑B)
inst✝ : Module.Free ↥B ↥(Algebra.adjoin ↥B ↑A)
⊢ finrank R ↥(A ⊔ B) = finrank R ↥B * finrank ↥B ↥(Algebra.adjoin ↥B ↑A)
state_after: no goals
Theorem: MeasureTheory.integral_comp_mul_deriv_Ioi
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: have hg2' : IntegrableOn (fun x => f' x • (g ∘ f) x) (Ici a) := by simpa [mul_comm] using hg2
state_before: E : Type u_1
f✝ : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f f' g : ℝ → ℝ
a : ℝ
hf : ContinuousOn f (Ici a)
hft : Tendsto f atTop atTop
hff' : ∀ x ∈ Ioi a, HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioi a)
hg1 : IntegrableOn g (f '' Ici a) volume
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) (Ici a) volume
⊢ ∫ (x : ℝ) in Ioi a, (g ∘ f) x * f' x = ∫ (u : ℝ) in Ioi (f a), g u
state_after: E : Type u_1
f✝ : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f f' g : ℝ → ℝ
a : ℝ
hf : ContinuousOn f (Ici a)
hft : Tendsto f atTop atTop
hff' : ∀ x ∈ Ioi a, HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioi a)
hg1 : IntegrableOn g (f '' Ici a) volume
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) (Ici a) volume
hg2' : IntegrableOn (fun x => f' x • (g ∘ f) x) (Ici a) volume
⊢ ∫ (x : ℝ) in Ioi a, (g ∘ f) x * f' x = ∫ (u : ℝ) in Ioi (f a), g u

tactic: simpa [mul_comm] using integral_comp_smul_deriv_Ioi hf hft hff' hg_cont hg1 hg2'
state_before: E : Type u_1
f✝ : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f f' g : ℝ → ℝ
a : ℝ
hf : ContinuousOn f (Ici a)
hft : Tendsto f atTop atTop
hff' : ∀ x ∈ Ioi a, HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioi a)
hg1 : IntegrableOn g (f '' Ici a) volume
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) (Ici a) volume
hg2' : IntegrableOn (fun x => f' x • (g ∘ f) x) (Ici a) volume
⊢ ∫ (x : ℝ) in Ioi a, (g ∘ f) x * f' x = ∫ (u : ℝ) in Ioi (f a), g u
state_after: no goals

tactic: simpa [mul_comm] using hg2
state_before: E : Type u_1
f✝ : ℝ → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f f' g : ℝ → ℝ
a : ℝ
hf : ContinuousOn f (Ici a)
hft : Tendsto f atTop atTop
hff' : ∀ x ∈ Ioi a, HasDerivWithinAt f (f' x) (Ioi x) x
hg_cont : ContinuousOn g (f '' Ioi a)
hg1 : IntegrableOn g (f '' Ici a) volume
hg2 : IntegrableOn (fun x => (g ∘ f) x * f' x) (Ici a) volume
⊢ IntegrableOn (fun x => f' x • (g ∘ f) x) (Ici a) volume
state_after: no goals
Theorem: Nat.mul_div_lt_iff_not_dvd
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [Nat.lt_iff_le_and_ne, mul_div_eq_iff_dvd, mul_div_le]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ d * (n / d) < n ↔ ¬d ∣ n
state_after: no goals
Theorem: SubfieldClass.ratCast_mem
File: Mathlib/Algebra/Field/Subfield.lean

tactic: simpa only [Rat.cast_def] using div_mem (intCast_mem s q.num) (natCast_mem s q.den)
state_before: K : Type u
L : Type v
M : Type w
inst✝³ : DivisionRing K
inst✝² : DivisionRing L
inst✝¹ : DivisionRing M
S : Type u_1
inst✝ : SetLike S K
h : SubfieldClass S K
x : K
s : S
q : ℚ
⊢ ↑q ∈ s
state_after: no goals
Theorem: Set.preimage_coe_coe_diagonal
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
state_before: α : Type u_1
s✝ t s : Set α
⊢ (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' diagonal α = diagonal ↑s
state_after: case h.mk.mk.mk
α : Type u_1
s✝ t s : Set α
x : α
hx : x ∈ s
y : α
hy : y ∈ s
⊢ (⟨x, hx⟩, ⟨y, hy⟩) ∈ (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' diagonal α ↔ (⟨x, hx⟩, ⟨y, hy⟩) ∈ diagonal ↑s

tactic: simp [Set.diagonal]
state_before: case h.mk.mk.mk
α : Type u_1
s✝ t s : Set α
x : α
hx : x ∈ s
y : α
hy : y ∈ s
⊢ (⟨x, hx⟩, ⟨y, hy⟩) ∈ (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' diagonal α ↔ (⟨x, hx⟩, ⟨y, hy⟩) ∈ diagonal ↑s
state_after: no goals
Theorem: Complex.cos_add_aux
File: Mathlib/Data/Complex/Exponential.lean

tactic: ring
state_before: x y a b c d : ℂ
⊢ (a + b) * (c + d) - (b - a) * (d - c) * -1 = 2 * (a * c + b * d)
state_after: no goals
Theorem: Asymptotics.isBigOWith_map
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
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✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
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 α
k : β → α
l : Filter β
⊢ IsBigOWith c (map k l) f g ↔ IsBigOWith c l (f ∘ k) (g ∘ k)
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
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✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
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 α
k : β → α
l : Filter β
⊢ (∀ᶠ (x : α) in map k l, ‖f x‖ ≤ c * ‖g x‖) ↔ ∀ᶠ (x : β) in l, ‖(f ∘ k) x‖ ≤ c * ‖(g ∘ k) x‖

tactic: exact eventually_map
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
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✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
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 α
k : β → α
l : Filter β
⊢ (∀ᶠ (x : α) in map k l, ‖f x‖ ≤ c * ‖g x‖) ↔ ∀ᶠ (x : β) in l, ‖(f ∘ k) x‖ ≤ c * ‖(g ∘ k) x‖
state_after: no goals
Theorem: cast_bijective
File: Mathlib/Logic/Function/Basic.lean

tactic: cases h
state_before: α✝ : Sort u_1
β✝ : Sort u_2
α β : Sort u_3
h : α = β
⊢ Bijective (cast h)
state_after: case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective (cast ⋯)

tactic: exact ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩
state_before: case refl
α✝ : Sort u_1
β : Sort u_2
α : Sort u_3
⊢ Bijective (cast ⋯)
state_after: no goals
Theorem: half_sub
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: rw [← neg_sub, sub_half]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
a : R
⊢ a / 2 - a = -(a / 2)
state_after: no goals
Theorem: UniqueFactorizationMonoid.normalizedFactors_eq_of_dvd
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: intro p hp q hq hdvd
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ ∀ p ∈ normalizedFactors a, ∀ q ∈ normalizedFactors a, p ∣ q → p = q
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
hp : p ∈ normalizedFactors a
q : α
hq : q ∈ normalizedFactors a
hdvd : p ∣ q
⊢ p = q

tactic: convert normalize_eq_normalize hdvd
        ((prime_of_normalized_factor _ hp).irreducible.dvd_symm
          (prime_of_normalized_factor _ hq).irreducible hdvd) <;>
  apply (normalize_normalized_factor _ ‹_›).symm
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a p : α
hp : p ∈ normalizedFactors a
q : α
hq : q ∈ normalizedFactors a
hdvd : p ∣ q
⊢ p = q
state_after: no goals
Theorem: Filter.mem_top
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [mem_top_iff_forall, eq_univ_iff_forall]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t s : Set α
⊢ s ∈ ⊤ ↔ s = univ
state_after: no goals
Theorem: tprod_subtype
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: rw [← tprod_subtype_eq_of_mulSupport_subset Set.mulSupport_mulIndicator_subset, tprod_congr]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∏' (x : ↑s), f ↑x = ∏' (x : β), s.mulIndicator f x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∀ (b : ↑s), f ↑b = s.mulIndicator f ↑b

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Set β
f : β → α
⊢ ∀ (b : ↑s), f ↑b = s.mulIndicator f ↑b
state_after: no goals
Theorem: finite_zpowers
File: Mathlib/Data/ZMod/Quotient.lean

tactic: simp only [← orderOf_pos_iff, ← Nat.card_zpowers, Nat.card_pos_iff, ← SetLike.coe_sort_coe,
  nonempty_coe_sort, Nat.card_pos_iff, Set.finite_coe_iff, Subgroup.coe_nonempty, true_and]
state_before: n : ℕ
A : Type u_1
R : Type u_2
inst✝² : AddGroup A
inst✝¹ : Ring R
α : Type u_3
inst✝ : Group α
a : α
⊢ (↑(zpowers a)).Finite ↔ IsOfFinOrder a
state_after: no goals
Theorem: Ordinal.one_add_omega
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: refine le_antisymm ?_ (le_add_left _ _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ 1 + ω = ω
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ 1 + ω ≤ ω

tactic: rw [omega, ← lift_one.{0}, ← lift_add, lift_le, ← type_unit, ← type_sum_lex]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ 1 + ω ≤ ω
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ type (Sum.Lex EmptyRelation fun x x_1 => x < x_1) ≤ type fun x x_1 => x < x_1

tactic: refine ⟨RelEmbedding.collapse (RelEmbedding.ofMonotone ?_ ?_)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ type (Sum.Lex EmptyRelation fun x x_1 => x < x_1) ≤ type fun x x_1 => x < x_1
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Unit ⊕ ℕ → ℕ

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ∀ (a b : Unit ⊕ ℕ), Sum.Lex EmptyRelation (fun x x_1 => x < x_1) a b → ?refine_1 a < ?refine_1 b

tactic: apply Sum.rec
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Unit ⊕ ℕ → ℕ
state_after: case refine_1.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Unit → ℕ

case refine_1.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ℕ → ℕ

tactic: exact fun _ => 0
state_before: case refine_1.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Unit → ℕ
state_after: no goals

tactic: exact Nat.succ
state_before: case refine_1.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ℕ → ℕ
state_after: no goals

tactic: intro a b
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ∀ (a b : Unit ⊕ ℕ),
    Sum.Lex EmptyRelation (fun x x_1 => x < x_1) a b → Sum.rec (fun x => 0) Nat.succ a < Sum.rec (fun x => 0) Nat.succ b
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Unit ⊕ ℕ
⊢ Sum.Lex EmptyRelation (fun x x_1 => x < x_1) a b → Sum.rec (fun x => 0) Nat.succ a < Sum.rec (fun x => 0) Nat.succ b

tactic: cases a <;> cases b <;> intro H <;> cases' H with _ _ H _ _ H <;>
  [exact H.elim; exact Nat.succ_pos _; exact Nat.succ_lt_succ H]
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Unit ⊕ ℕ
⊢ Sum.Lex EmptyRelation (fun x x_1 => x < x_1) a b → Sum.rec (fun x => 0) Nat.succ a < Sum.rec (fun x => 0) Nat.succ b
state_after: no goals
Theorem: List.eq_cons_of_length_one
File: Mathlib/Data/List/Basic.lean

tactic: omega
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
⊢ 0 < l.length
state_after: no goals

tactic: refine ext_get (by convert h) fun n h₁ h₂ => ?_
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
⊢ l = [l.nthLe 0 ⋯]
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
n : ℕ
h₁ : n < l.length
h₂ : n < [l.nthLe 0 ⋯].length
⊢ l.get ⟨n, h₁⟩ = [l.nthLe 0 ⋯].get ⟨n, h₂⟩

tactic: simp only [get_singleton]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
n : ℕ
h₁ : n < l.length
h₂ : n < [l.nthLe 0 ⋯].length
⊢ l.get ⟨n, h₁⟩ = [l.nthLe 0 ⋯].get ⟨n, h₂⟩
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
n : ℕ
h₁ : n < l.length
h₂ : n < [l.nthLe 0 ⋯].length
⊢ l.get ⟨n, h₁⟩ = l.nthLe 0 ⋯

tactic: congr
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
n : ℕ
h₁ : n < l.length
h₂ : n < [l.nthLe 0 ⋯].length
⊢ l.get ⟨n, h₁⟩ = l.nthLe 0 ⋯
state_after: case e_a.e_val
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
n : ℕ
h₁ : n < l.length
h₂ : n < [l.nthLe 0 ⋯].length
⊢ n = 0

tactic: omega
state_before: case e_a.e_val
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
n : ℕ
h₁ : n < l.length
h₂ : n < [l.nthLe 0 ⋯].length
⊢ n = 0
state_after: no goals

tactic: convert h
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
h : l.length = 1
⊢ l.length = [l.nthLe 0 ⋯].length
state_after: no goals
Theorem: Vector.nodup_iff_injective_get
File: Mathlib/Data/Vector/Basic.lean

tactic: cases' v with l hl
state_before: n : ℕ
α : Type u_1
v : Vector α n
⊢ v.toList.Nodup ↔ Function.Injective v.get
state_after: case mk
n : ℕ
α : Type u_1
l : List α
hl : l.length = n
⊢ (toList ⟨l, hl⟩).Nodup ↔ Function.Injective (get ⟨l, hl⟩)

tactic: subst hl
state_before: case mk
n : ℕ
α : Type u_1
l : List α
hl : l.length = n
⊢ (toList ⟨l, hl⟩).Nodup ↔ Function.Injective (get ⟨l, hl⟩)
state_after: case mk
α : Type u_1
l : List α
⊢ (toList ⟨l, ⋯⟩).Nodup ↔ Function.Injective (get ⟨l, ⋯⟩)

tactic: exact List.nodup_iff_injective_get
state_before: case mk
α : Type u_1
l : List α
⊢ (toList ⟨l, ⋯⟩).Nodup ↔ Function.Injective (get ⟨l, ⋯⟩)
state_after: no goals
Theorem: PolyEquivTensor.toFunBilinear_apply_eq_sum
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: simp only [toFunBilinear_apply_apply, aeval_def, eval₂_eq_sum, Polynomial.sum, Finset.smul_sum]
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
⊢ ((toFunBilinear R A) a) p = p.sum fun n r => (monomial n) (a * (algebraMap R A) r)
state_after: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
⊢ ∑ x ∈ p.support, a • ((algebraMap R A[X]) (p.coeff x) * X ^ x) =
    ∑ x ∈ p.support, (monomial x) (a * (algebraMap R A) (p.coeff x))

tactic: congr with i : 1
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
⊢ ∑ x ∈ p.support, a • ((algebraMap R A[X]) (p.coeff x) * X ^ x) =
    ∑ x ∈ p.support, (monomial x) (a * (algebraMap R A) (p.coeff x))
state_after: case e_f.h
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
i : ℕ
⊢ a • ((algebraMap R A[X]) (p.coeff i) * X ^ i) = (monomial i) (a * (algebraMap R A) (p.coeff i))

tactic: rw [← Algebra.smul_def, ← C_mul', mul_smul_comm, C_mul_X_pow_eq_monomial, ← Algebra.commutes,
  ← Algebra.smul_def, smul_monomial]
state_before: case e_f.h
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
i : ℕ
⊢ a • ((algebraMap R A[X]) (p.coeff i) * X ^ i) = (monomial i) (a * (algebraMap R A) (p.coeff i))
state_after: no goals
Theorem: Pretrivialization.coe_linearMapAt_of_mem
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: simp_rw [coe_linearMapAt, if_pos hb]
state_before: R : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
inst✝⁷ : Semiring R
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace B
e✝ : Pretrivialization F TotalSpace.proj
x : TotalSpace F E
b✝ : B
y : E b✝
inst✝⁴ : AddCommMonoid F
inst✝³ : Module R F
inst✝² : (x : B) → AddCommMonoid (E x)
inst✝¹ : (x : B) → Module R (E x)
e : Pretrivialization F TotalSpace.proj
inst✝ : Pretrivialization.IsLinear R e
b : B
hb : b ∈ e.baseSet
⊢ ⇑(Pretrivialization.linearMapAt R e b) = fun y => (↑e { proj := b, snd := y }).2
state_after: no goals