ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: map_extChartAt_nhds_of_boundaryless
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝² : ChartedSpace H M
inst✝¹ : ChartedSpace H' M'
inst✝ : I.Boundaryless
x : M
⊢ map (↑(extChartAt I x)) (𝓝 x) = 𝓝 (↑(extChartAt I x) x)
state_after: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝² : ChartedSpace H M
inst✝¹ : ChartedSpace H' M'
inst✝ : I.Boundaryless
x : M
⊢ map (↑((chartAt H x).extend I)) (𝓝 x) = 𝓝 (↑((chartAt H x).extend I) x)
tactic: rw [extChartAt]
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : TopologicalSpace H
inst✝⁷ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : NormedSpace 𝕜 E'
inst✝⁴ : TopologicalSpace H'
inst✝³ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝² : ChartedSpace H M
inst✝¹ : ChartedSpace H' M'
inst✝ : I.Boundaryless
x : M
⊢ map (↑((chartAt H x).extend I)) (𝓝 x) = 𝓝 (↑((chartAt H x).extend I) x)
state_after: no goals
tactic: exact map_extend_nhds_of_boundaryless (chartAt H x) I (mem_chart_source H x)
Theorem: NormedAddGroupHom.norm_completion
File: Mathlib/Analysis/Normed/Group/HomCompletion.lean

Proof steps:
state_before: G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type u_3
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
x : G
⊢ ‖f x‖ ≤ ‖f.completion‖ * ‖x‖
state_after: no goals
tactic: simpa using f.completion.le_opNorm x
Theorem: Finset.isGLB_mem
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
i : α
s : Finset α
his : IsGLB (↑s) i
hs : s.Nonempty
⊢ i ∈ s
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
i : α
s : Finset α
his : IsGLB (↑s) i
hs : s.Nonempty
⊢ i ∈ ↑s
tactic: rw [← mem_coe]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
i : α
s : Finset α
his : IsGLB (↑s) i
hs : s.Nonempty
⊢ i ∈ ↑s
state_after: no goals
tactic: exact ((isGLB_iff_isLeast i s hs).mp his).1
Theorem: rank_range_le
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
f : M →ₗ[R] M₁
⊢ Module.rank R ↥(LinearMap.range f) ≤ Module.rank R M
state_after: no goals
tactic: simpa using lift_rank_range_le f
Theorem: Matrix.vecMul_sub
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype m
A B : Matrix m n α
x : m → α
⊢ x ᵥ* (A - B) = x ᵥ* A - x ᵥ* B
state_after: no goals
tactic: simp [sub_eq_add_neg, vecMul_add, vecMul_neg]
Theorem: NNReal.coe_sInf
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
⊢ ↑(sInf s) = sInf (toReal '' s)
state_after: case inl
r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ ↑(sInf ∅) = sInf (toReal '' ∅)

case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ ↑(sInf s) = sInf (toReal '' s)
tactic: rcases Set.eq_empty_or_nonempty s with rfl|hs
state_before: case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ ↑(sInf s) = sInf (toReal '' s)
state_after: case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
A : sInf (Subtype.val '' s) ∈ Set.Ici 0
⊢ ↑(sInf s) = sInf (toReal '' s)
tactic: have A : sInf (Subtype.val '' s) ∈ Set.Ici 0 := by
    apply Real.sInf_nonneg
    rintro - ⟨y, -, rfl⟩
    exact y.2
state_before: case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
A : sInf (Subtype.val '' s) ∈ Set.Ici 0
⊢ ↑(sInf s) = sInf (toReal '' s)
state_after: no goals
tactic: exact (@subset_sInf_of_within ℝ (Set.Ici (0 : ℝ)) _ _ (_) s hs (OrderBot.bddBelow s) A).symm
Theorem: PythagoreanTriple.coprime_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

Proof steps:
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
⊢ y.gcd z = 1
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
⊢ False
tactic: by_contra H
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
⊢ False
state_after: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ False
tactic: obtain ⟨p, hp, hpy, hpz⟩ := Nat.Prime.not_coprime_iff_dvd.mp H
state_before: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ False
state_after: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ p ∣ 1
tactic: apply hp.not_dvd_one
state_before: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ p ∣ 1
state_after: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ p ∣ x.gcd y
tactic: rw [← hc]
state_before: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ p ∣ x.gcd y
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ ↑p ∣ x ^ 2
tactic: apply Nat.dvd_gcd (Int.Prime.dvd_natAbs_of_coe_dvd_sq hp _ _) hpy
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ ↑p ∣ x ^ 2
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ ↑p ∣ z * z - y * y
tactic: rw [sq, eq_sub_of_add_eq h]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ y.natAbs
hpz : p ∣ z.natAbs
⊢ ↑p ∣ z * z - y * y
state_after: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : ↑p ∣ y
hpz : ↑p ∣ z
⊢ ↑p ∣ z * z - y * y
tactic: rw [← Int.natCast_dvd] at hpy hpz
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : x.gcd y = 1
H : ¬y.gcd z = 1
p : ℕ
hp : Nat.Prime p
hpy : ↑p ∣ y
hpz : ↑p ∣ z
⊢ ↑p ∣ z * z - y * y
state_after: no goals
tactic: exact dvd_sub (hpz.mul_right _) (hpy.mul_right _)
Theorem: Irreducible.hasSeparableContraction
File: Mathlib/RingTheory/Polynomial/SeparableDegree.lean

Proof steps:
state_before: F : Type u_1
inst✝ : Field F
q✝ : ℕ
f✝ : F[X]
hf : HasSeparableContraction q✝ f✝
q : ℕ
hF : ExpChar F q
f : F[X]
irred : Irreducible f
⊢ HasSeparableContraction q f
state_after: case zero
F : Type u_1
inst✝¹ : Field F
q : ℕ
f✝ : F[X]
hf : HasSeparableContraction q f✝
f : F[X]
irred : Irreducible f
inst✝ : CharZero F
⊢ HasSeparableContraction 1 f

case prime
F : Type u_1
inst✝ : Field F
q✝ : ℕ
f✝ : F[X]
hf : HasSeparableContraction q✝ f✝
q : ℕ
f : F[X]
irred : Irreducible f
hprime✝ : Nat.Prime q
hchar✝ : CharP F q
⊢ HasSeparableContraction q f
tactic: cases hF
Theorem: FirstOrder.Language.exists_countable_is_age_of_iff
File: Mathlib/ModelTheory/Fraisse.lean

Proof steps:
state_before: L : Language
K : Set (Bundled L.Structure)
M : Type w
inst✝² : L.Structure M
N : Type w
inst✝¹ : L.Structure N
inst✝ : Countable ((l : ℕ) × L.Functions l)
⊢ (∃ M, Countable ↑M ∧ L.age ↑M = K) ↔
    K.Nonempty ∧
      (∀ (M N : Bundled L.Structure), Nonempty (↑M ≃[L] ↑N) → (M ∈ K ↔ N ∈ K)) ∧
        (Quotient.mk' '' K).Countable ∧ (∀ M ∈ K, Structure.FG L ↑M) ∧ Hereditary K ∧ JointEmbedding K
state_after: case mp
L : Language
K : Set (Bundled L.Structure)
M : Type w
inst✝² : L.Structure M
N : Type w
inst✝¹ : L.Structure N
inst✝ : Countable ((l : ℕ) × L.Functions l)
⊢ (∃ M, Countable ↑M ∧ L.age ↑M = K) →
    K.Nonempty ∧
      (∀ (M N : Bundled L.Structure), Nonempty (↑M ≃[L] ↑N) → (M ∈ K ↔ N ∈ K)) ∧
        (Quotient.mk' '' K).Countable ∧ (∀ M ∈ K, Structure.FG L ↑M) ∧ Hereditary K ∧ JointEmbedding K

case mpr
L : Language
K : Set (Bundled L.Structure)
M : Type w
inst✝² : L.Structure M
N : Type w
inst✝¹ : L.Structure N
inst✝ : Countable ((l : ℕ) × L.Functions l)
⊢ K.Nonempty ∧
      (∀ (M N : Bundled L.Structure), Nonempty (↑M ≃[L] ↑N) → (M ∈ K ↔ N ∈ K)) ∧
        (Quotient.mk' '' K).Countable ∧ (∀ M ∈ K, Structure.FG L ↑M) ∧ Hereditary K ∧ JointEmbedding K →
    ∃ M, Countable ↑M ∧ L.age ↑M = K
tactic: constructor
Theorem: CategoryTheory.MonoidalCategory.prodMonoidal_rightUnitor_hom_fst
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
X : C₁ × C₂
⊢ (ρ_ X).hom.1 = (ρ_ X.1).hom
state_after: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).hom.1 = (ρ_ (fst✝, snd✝).1).hom
tactic: cases X
state_before: case mk
C : Type u
𝒞 : Category.{v, u} C
inst✝⁴ : MonoidalCategory C
C₁ : Type u₁
inst✝³ : Category.{v₁, u₁} C₁
inst✝² : MonoidalCategory C₁
C₂ : Type u₂
inst✝¹ : Category.{v₂, u₂} C₂
inst✝ : MonoidalCategory C₂
fst✝ : C₁
snd✝ : C₂
⊢ (ρ_ (fst✝, snd✝)).hom.1 = (ρ_ (fst✝, snd✝).1).hom
state_after: no goals
tactic: rfl
Theorem: ZFSet.map_unique
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => z.pair w ∈ map f x) y
⊢ y = f z
state_after: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => z.pair w ∈ map f x) y
w : ZFSet
left✝ : w ∈ x
we : w.pair (f w) = z.pair y
⊢ y = f z
tactic: let ⟨w, _, we⟩ := mem_image.1 yx
state_before: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => z.pair w ∈ map f x) y
w : ZFSet
left✝ : w ∈ x
we : w.pair (f w) = z.pair y
⊢ y = f z
state_after: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => z.pair w ∈ map f x) y
w : ZFSet
left✝ : w ∈ x
we : w.pair (f w) = z.pair y
wz : w = z
fy : f w = y
⊢ y = f z
tactic: let ⟨wz, fy⟩ := pair_injective we
state_before: f : ZFSet → ZFSet
H : Definable 1 f
x z : ZFSet
zx : z ∈ x
y : ZFSet
yx : (fun w => z.pair w ∈ map f x) y
w : ZFSet
left✝ : w ∈ x
we : w.pair (f w) = z.pair y
wz : w = z
fy : f w = y
⊢ y = f z
state_after: no goals
tactic: rw [← fy, wz]
Theorem: Ideal.Filtration.Stable.exists_pow_smul_eq
File: Mathlib/RingTheory/Filtration.lean

Proof steps:
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
h : F.Stable
⊢ ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀
state_after: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
⊢ ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀
tactic: obtain ⟨n₀, hn⟩ := h
state_before: case intro
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
⊢ ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀
state_after: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
⊢ ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀
tactic: use n₀
state_before: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
⊢ ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀
state_after: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
k : ℕ
⊢ F.N (n₀ + k) = I ^ k • F.N n₀
tactic: intro k
state_before: case h
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
k : ℕ
⊢ F.N (n₀ + k) = I ^ k • F.N n₀
state_after: case h.zero
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
⊢ F.N (n₀ + 0) = I ^ 0 • F.N n₀

case h.succ
R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : I.Filtration M
n₀ : ℕ
hn : ∀ n ≥ n₀, I • F.N n = F.N (n + 1)
n✝ : ℕ
ih : F.N (n₀ + n✝) = I ^ n✝ • F.N n₀
⊢ F.N (n₀ + (n✝ + 1)) = I ^ (n✝ + 1) • F.N n₀
tactic: induction' k with _ ih
Theorem: Function.extend_mul
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ * g₂) (e₁ * e₂) = extend f g₁ e₁ * extend f g₂ e₂
state_after: no goals
tactic: classical
  funext x
  simp only [not_exists, extend_def, Pi.mul_apply, apply_dite₂, dite_eq_ite, ite_self]
Theorem: summable_of_finite_support
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ Multipliable f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ ∀ b ∉ h.toFinset, f b = 1
tactic: apply multipliable_of_ne_finset_one (s := h.toFinset)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ ∀ b ∉ h.toFinset, f b = 1
state_after: no goals
tactic: simp
Theorem: Cardinal.card_le_of_le_ord
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
c : Cardinal.{u_3}
ho : o ≤ c.ord
⊢ o.card ≤ c
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
c : Cardinal.{u_3}
ho : o ≤ c.ord
⊢ o.card ≤ c.ord.card
tactic: rw [← card_ord c]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
c : Cardinal.{u_3}
ho : o ≤ c.ord
⊢ o.card ≤ c.ord.card
state_after: no goals
tactic: exact Ordinal.card_le_card ho
Theorem: Submodule.span_insert_zero
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ span R (insert 0 s) = span R s
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ span R (insert 0 s) ≤ span R s
tactic: refine le_antisymm ?_ (Submodule.span_mono (Set.subset_insert 0 s))
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ span R (insert 0 s) ≤ span R s
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ 0 ∈ ↑(span R s) ∧ s ⊆ ↑(span R s)
tactic: rw [span_le, Set.insert_subset_iff]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ 0 ∈ ↑(span R s) ∧ s ⊆ ↑(span R s)
state_after: no goals
tactic: exact ⟨by simp only [SetLike.mem_coe, Submodule.zero_mem], Submodule.subset_span⟩
Theorem: CategoryTheory.FreeMonoidalCategory.normalizeObj_congr
File: Mathlib/CategoryTheory/Monoidal/Free/Coherence.lean

Proof steps:
state_before: C : Type u
n : NormalMonoidalObject C
X Y : F C
f : X ⟶ Y
⊢ X.normalizeObj n = Y.normalizeObj n
state_after: case mk
C : Type u
n : NormalMonoidalObject C
X Y : F C
f : X ⟶ Y
f' : X ⟶ᵐ Y
⊢ X.normalizeObj n = Y.normalizeObj n
tactic: rcases f with ⟨f'⟩
state_before: case mk
C : Type u
n : NormalMonoidalObject C
X Y : F C
f : X ⟶ Y
f' : X ⟶ᵐ Y
⊢ X.normalizeObj n = Y.normalizeObj n
state_after: case mk.h
C : Type u
n : NormalMonoidalObject C
X Y : F C
f : X ⟶ Y
f' : X ⟶ᵐ Y
⊢ (fun n => X.normalizeObj n) = Y.normalizeObj
tactic: apply @congr_fun _ _ fun n => normalizeObj X n
state_before: case mk.h
C : Type u
n : NormalMonoidalObject C
X Y : F C
f : X ⟶ Y
f' : X ⟶ᵐ Y
⊢ (fun n => X.normalizeObj n) = Y.normalizeObj
state_after: case mk.h
C : Type u
X Y : F C
f' : X ⟶ᵐ Y
⊢ (fun n => X.normalizeObj n) = Y.normalizeObj
tactic: clear n f
state_before: case mk.h
C : Type u
X Y : F C
f' : X ⟶ᵐ Y
⊢ (fun n => X.normalizeObj n) = Y.normalizeObj
state_after: no goals
tactic: induction f' with
  | comp _ _ _ _ => apply Eq.trans <;> assumption
  | whiskerLeft  _ _ ih => funext; apply congr_fun ih
  | whiskerRight _ _ ih => funext; apply congr_arg₂ _ rfl (congr_fun ih _)
  | @tensor W X Y Z _ _ ih₁ ih₂ =>
      funext n
      simp [congr_fun ih₁ n, congr_fun ih₂ (normalizeObj Y n)]
  | _ => funext; rfl
Theorem: Finsupp.sum_cons
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
n : ℕ
σ : Fin n →₀ M
i : M
⊢ ((cons i σ).sum fun x e => e) = i + σ.sum fun x e => e
state_after: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
n : ℕ
σ : Fin n →₀ M
i : M
⊢ ∑ i_1 : Fin (n + 1), (cons i σ) i_1 = i + ∑ i : Fin n, σ i
tactic: rw [sum_fintype _ _ (fun _ => rfl), sum_fintype _ _ (fun _ => rfl)]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝³ : AddCommMonoid A
inst✝² : AddCommMonoid B
inst✝¹ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f : α → ι →₀ A
i✝ : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝ : AddCommMonoid M
n : ℕ
σ : Fin n →₀ M
i : M
⊢ ∑ i_1 : Fin (n + 1), (cons i σ) i_1 = i + ∑ i : Fin n, σ i
state_after: no goals
tactic: exact Fin.sum_cons i σ
Theorem: GaloisInsertion.l_inf_u
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a✝ a₁ a₂ : α
b✝ b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
gi : GaloisInsertion l u
a b : β
⊢ l (u (a ⊓ b)) = a ⊓ b
state_after: no goals
tactic: simp only [gi.l_u_eq]
Theorem: SetTheory.PGame.moveRight_neg
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
i : x.LeftMoves
⊢ (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i
state_after: case mk
xl xr : Type u
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (-mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesNeg i) = -(mk α✝ β✝ a✝¹ a✝).moveLeft i
tactic: cases x
state_before: case mk
xl xr : Type u
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (-mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesNeg i) = -(mk α✝ β✝ a✝¹ a✝).moveLeft i
state_after: no goals
tactic: rfl
Theorem: Basis.smul_det
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
M' : Type u_3
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M'
ι : Type u_4
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
e : Basis ι R M
G : Type u_5
inst✝² : Group G
inst✝¹ : DistribMulAction G M
inst✝ : SMulCommClass G R M
g : G
v : ι → M
⊢ (g • e).det v = e.det (g⁻¹ • v)
state_after: no goals
tactic: simp_rw [det_apply, toMatrix_smul_left]
Theorem: Fin.card_filter_univ_succ'
File: Mathlib/Data/Fintype/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (filter p univ).card = (if p 0 then 1 else 0) + (filter (p ∘ succ) univ).card
state_after: α : Type u_1
β : Type u_2
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (if p 0 then {0} else ∅).card + (filter (p ∘ ⇑{ toFun := succ, inj' := ⋯ }) univ).card =
    (if p 0 then 1 else 0) + (filter (p ∘ succ) univ).card
tactic: rw [Fin.univ_succ, filter_cons, card_disjUnion, filter_map, card_map]
state_before: α : Type u_1
β : Type u_2
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (if p 0 then {0} else ∅).card + (filter (p ∘ ⇑{ toFun := succ, inj' := ⋯ }) univ).card =
    (if p 0 then 1 else 0) + (filter (p ∘ succ) univ).card
state_after: no goals
tactic: split_ifs <;> simp