ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShiftMkCore.shiftFunctorZero_eq
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
⊢ shiftFunctorZero C A = h.zero
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ shiftFunctorZero C A = h.zero
tactic: letI := hasShiftMk C A h
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ shiftFunctorZero C A = h.zero
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftMonoidalFunctor C A).εIso.symm = h.zero
tactic: dsimp [shiftFunctorZero]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftMonoidalFunctor C A).εIso.symm = h.zero
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
tactic: change (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
state_after: case e_I
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm = h.zero.symm
tactic: congr 1
state_before: case e_I
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm = h.zero.symm
state_after: case e_I.w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
x✝ : C
⊢ (shiftFunctorZero C A).symm.hom.app x✝ = h.zero.symm.hom.app x✝
tactic: ext
state_before: case e_I.w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
x✝ : C
⊢ (shiftFunctorZero C A).symm.hom.app x✝ = h.zero.symm.hom.app x✝
state_after: no goals
tactic: rfl
Theorem: isMulFreimanHom_id
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hA : A₁ ⊆ A₂
s t : Multiset α
x✝³ : ∀ ⦃x : α⦄, x ∈ s → x ∈ A₁
x✝² : ∀ ⦃x : α⦄, x ∈ t → x ∈ A₁
x✝¹ : card s = n
x✝ : card t = n
h : s.prod = t.prod
⊢ (map id s).prod = (map id t).prod
state_after: no goals
tactic: simpa using h
Theorem: Sym.exists
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
p : Sym α n → Prop
⊢ (∃ s, p s) ↔ ∃ s, ∃ (hs : Multiset.card s = n), p (mk s hs)
state_after: no goals
tactic: simp [Sym]
Theorem: MeasureTheory.hitting_mem_set_of_hitting_lt
File: Mathlib/Probability/Process/HittingTime.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
⊢ u (hitting u s n m ω) ω ∈ s
state_after: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ u (hitting u s n m ω) ω ∈ s

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
m : ι
hl : hitting u s n m ω < m
h : ¬∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ u (hitting u s n m ω) ω ∈ s
tactic: by_cases h : ∃ j ∈ Set.Icc n m, u j ω ∈ s
Theorem: MeasureTheory.tendsto_measure_iInter
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
s : ι → Set α
hs : ∀ (n : ι), MeasurableSet (s n)
hm : Antitone s
hf : ∃ i, μ (s i) ≠ ⊤
⊢ Tendsto (⇑μ ∘ s) atTop (𝓝 (μ (⋂ n, s n)))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
s : ι → Set α
hs : ∀ (n : ι), MeasurableSet (s n)
hm : Antitone s
hf : ∃ i, μ (s i) ≠ ⊤
⊢ Tendsto (⇑μ ∘ s) atTop (𝓝 (⨅ i, μ (s i)))
tactic: rw [measure_iInter_eq_iInf hs hm.directed_ge hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
s : ι → Set α
hs : ∀ (n : ι), MeasurableSet (s n)
hm : Antitone s
hf : ∃ i, μ (s i) ≠ ⊤
⊢ Tendsto (⇑μ ∘ s) atTop (𝓝 (⨅ i, μ (s i)))
state_after: no goals
tactic: exact tendsto_atTop_iInf fun n m hnm => measure_mono <| hm hnm
Theorem: PNat.recOn_succ
File: Mathlib/Data/PNat/Basic.lean

Proof steps:
state_before: n : ℕ+
p : ℕ+ → Sort u_1
p1 : p 1
hp : (n : ℕ+) → p n → p (n + 1)
⊢ (n + 1).recOn p1 hp = hp n (n.recOn p1 hp)
state_after: case mk
p : ℕ+ → Sort u_1
p1 : p 1
hp : (n : ℕ+) → p n → p (n + 1)
n : ℕ
h : 0 < n
⊢ (⟨n, h⟩ + 1).recOn p1 hp = hp ⟨n, h⟩ (recOn ⟨n, h⟩ p1 hp)
tactic: cases' n with n h
state_before: case mk
p : ℕ+ → Sort u_1
p1 : p 1
hp : (n : ℕ+) → p n → p (n + 1)
n : ℕ
h : 0 < n
⊢ (⟨n, h⟩ + 1).recOn p1 hp = hp ⟨n, h⟩ (recOn ⟨n, h⟩ p1 hp)
state_after: no goals
tactic: cases n <;> [exact absurd h (by decide); rfl]
Theorem: Nat.prime_mul_iff
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n a b : ℕ
⊢ Prime (a * b) ↔ Prime a ∧ b = 1 ∨ Prime b ∧ a = 1
state_after: no goals
tactic: simp only [iff_self_iff, irreducible_mul_iff, ← irreducible_iff_nat_prime, Nat.isUnit_iff]
Theorem: CategoryTheory.Idempotents.isIdempotentComplete_iff_opposite
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete Cᵒᵖ ↔ IsIdempotentComplete C
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete Cᵒᵖ → IsIdempotentComplete C

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
⊢ IsIdempotentComplete C → IsIdempotentComplete Cᵒᵖ
tactic: constructor
Theorem: QuadraticMap.map_sum'
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R M
inst✝⁶ : Module R N
Q✝ : QuadraticMap R M N
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : Module S N
inst✝ : IsScalarTower S R N
ι : Type u_8
Q : QuadraticMap R M N
s : Finset ι
f : ι → M
⊢ Q (∑ i ∈ s, f i) = ∑ ij ∈ s.sym2, Sym2.lift ⟨fun i j => polar (⇑Q) (f i) (f j), ⋯⟩ ij - ∑ i ∈ s, Q (f i)
state_after: no goals
tactic: induction s using Finset.cons_induction with
  | empty => simp
  | cons a s ha ih =>
    simp_rw [Finset.sum_cons, QuadraticMap.map_add Q, ih, add_assoc, Finset.sym2_cons,
      Finset.sum_disjUnion, Finset.sum_map, Finset.sum_cons, Sym2.mkEmbedding_apply, Sym2.lift_mk,
      ← polarBilin_apply_apply, _root_.map_sum, polarBilin_apply_apply, polar_self]
    abel_nf
Theorem: MeasureTheory.setLaverage_eq
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t : Set α
f✝ g f : α → ℝ≥0∞
s : Set α
⊢ ⨍⁻ (x : α) in s, f x ∂μ = (∫⁻ (x : α) in s, f x ∂μ) / μ s
state_after: no goals
tactic: rw [laverage_eq, restrict_apply_univ]
Theorem: List.dropLast_prefix
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ [].dropLast ++ [] = []
state_after: no goals
tactic: rw [dropLast, List.append_nil]
Theorem: Set.range_list_map_coe
File: Mathlib/Data/Set/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List α
s : Set α
⊢ range (map Subtype.val) = {l | ∀ x ∈ l, x ∈ s}
state_after: no goals
tactic: rw [range_list_map, Subtype.range_coe]
Theorem: MeasureTheory.OuterMeasure.ext_nonempty
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m μ₁ μ₂ : OuterMeasure α
h : ∀ (s : Set α), s.Nonempty → μ₁ s = μ₂ s
s : Set α
he : s = ∅
⊢ μ₁ s = μ₂ s
state_after: no goals
tactic: simp [he]
Theorem: Homeomorph.map_punctured_nhds_eq
File: Mathlib/Topology/Homeomorph.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
x : X
⊢ map (⇑h) (𝓝[≠] x) = 𝓝[≠] h x
state_after: case h.e'_3.h.e'_4
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
x : X
⊢ {h x}ᶜ = ⇑h '' {x}ᶜ
tactic: convert h.embedding.map_nhdsWithin_eq ({x}ᶜ) x
state_before: case h.e'_3.h.e'_4
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
x : X
⊢ {h x}ᶜ = ⇑h '' {x}ᶜ
state_after: no goals
tactic: rw [h.image_compl, Set.image_singleton]
Theorem: affineIndependent_equiv
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
⊢ AffineIndependent k (p ∘ ⇑e) ↔ AffineIndependent k p
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
⊢ AffineIndependent k (p ∘ ⇑e) → AffineIndependent k p
tactic: refine ⟨?_, AffineIndependent.comp_embedding e.toEmbedding⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
⊢ AffineIndependent k (p ∘ ⇑e) → AffineIndependent k p
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ⇑e)
⊢ AffineIndependent k p
tactic: intro h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ⇑e)
⊢ AffineIndependent k p
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ⇑e)
this : p = p ∘ ⇑e ∘ ⇑e.symm.toEmbedding
⊢ AffineIndependent k p
tactic: have : p = p ∘ e ∘ e.symm.toEmbedding := by
    ext
    simp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ⇑e)
this : p = p ∘ ⇑e ∘ ⇑e.symm.toEmbedding
⊢ AffineIndependent k p
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ⇑e)
this : p = p ∘ ⇑e ∘ ⇑e.symm.toEmbedding
⊢ AffineIndependent k (p ∘ ⇑e ∘ ⇑e.symm.toEmbedding)
tactic: rw [this]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
ι' : Type u_5
e : ι ≃ ι'
p : ι' → P
h : AffineIndependent k (p ∘ ⇑e)
this : p = p ∘ ⇑e ∘ ⇑e.symm.toEmbedding
⊢ AffineIndependent k (p ∘ ⇑e ∘ ⇑e.symm.toEmbedding)
state_after: no goals
tactic: exact h.comp_embedding e.symm.toEmbedding
Theorem: Complex.tendsto_self_mul_Gamma_nhds_zero
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: ⊢ Tendsto (fun z => z * Gamma z) (𝓝[≠] 0) (𝓝 1)
state_after: ⊢ Tendsto (fun z => z * Gamma z) (𝓝[≠] 0) (𝓝 (Gamma (0 + 1)))
tactic: rw [show 𝓝 (1 : ℂ) = 𝓝 (Gamma (0 + 1)) by simp only [zero_add, Complex.Gamma_one]]
state_before: ⊢ Tendsto (fun z => z * Gamma z) (𝓝[≠] 0) (𝓝 (Gamma (0 + 1)))
state_after: case convert_1

⊢ Tendsto (fun x => Gamma (x + 1)) (𝓝 0) (𝓝 (Gamma (0 + 1)))
tactic: convert (Tendsto.mono_left _ nhdsWithin_le_nhds).congr'
    (eventuallyEq_of_mem self_mem_nhdsWithin Complex.Gamma_add_one)
state_before: case convert_1

⊢ Tendsto (fun x => Gamma (x + 1)) (𝓝 0) (𝓝 (Gamma (0 + 1)))
state_after: case convert_1

⊢ ContinuousAt Gamma (0 + 1)
tactic: refine ContinuousAt.comp (g := Gamma) ?_ (continuous_id.add continuous_const).continuousAt
state_before: case convert_1

⊢ ContinuousAt Gamma (0 + 1)
state_after: case convert_1
m : ℕ
⊢ 0 + 1 ≠ -↑m
tactic: refine (Complex.differentiableAt_Gamma _ fun m => ?_).continuousAt
state_before: case convert_1
m : ℕ
⊢ 0 + 1 ≠ -↑m
state_after: case convert_1
m : ℕ
⊢ ¬1 = -↑m
tactic: rw [zero_add, ← ofReal_natCast, ← ofReal_neg, ← ofReal_one, Ne, ofReal_inj]
state_before: case convert_1
m : ℕ
⊢ ¬1 = -↑m
state_after: case convert_1
m : ℕ
⊢ -↑m ≤ 0
tactic: refine (lt_of_le_of_lt ?_ zero_lt_one).ne'
state_before: case convert_1
m : ℕ
⊢ -↑m ≤ 0
state_after: no goals
tactic: exact neg_nonpos.mpr (Nat.cast_nonneg _)
Theorem: Mathlib.Vector.get_mem
File: Mathlib/Data/Vector/Mem.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ v.get i ∈ v.toList
state_after: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ v.toList.get (Fin.cast ⋯ i) ∈ v.toList
tactic: rw [get_eq_get]
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ v.toList.get (Fin.cast ⋯ i) ∈ v.toList
state_after: no goals
tactic: exact List.get_mem _ _ _
Theorem: List.get_enumFrom
File: Mathlib/Data/List/Enum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List α
n : ℕ
i : Fin (enumFrom n l).length
⊢ (enumFrom n l).get i = (n + ↑i, l.get (Fin.cast ⋯ i))
state_after: no goals
tactic: simp
Theorem: FiniteDimensional.finrank_zero_iff
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
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✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ finrank R M = 0 ↔ Subsingleton M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
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✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ finrank R M = 0 ↔ ↑(finrank R M) = 0
tactic: rw [← rank_zero_iff (R := R), ← finrank_eq_rank]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
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✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ finrank R M = 0 ↔ ↑(finrank R M) = 0
state_after: no goals
tactic: norm_cast
Theorem: MeasureTheory.upcrossingsBefore_mono
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hab : a < b
⊢ Monotone fun N ω => upcrossingsBefore a b f N ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
hab : a < b
N M : ℕ
hNM : N ≤ M
ω : Ω
⊢ (fun N ω => upcrossingsBefore a b f N ω) N ω ≤ (fun N ω => upcrossingsBefore a b f N ω) M ω
tactic: intro N M hNM ω
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
hab : a < b
N M : ℕ
hNM : N ≤ M
ω : Ω
⊢ (fun N ω => upcrossingsBefore a b f N ω) N ω ≤ (fun N ω => upcrossingsBefore a b f N ω) M ω
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
hab : a < b
N M : ℕ
hNM : N ≤ M
ω : Ω
⊢ sSup {n | upperCrossingTime a b f N n ω < N} ≤ sSup {n | upperCrossingTime a b f M n ω < M}
tactic: simp only [upcrossingsBefore]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
hab : a < b
N M : ℕ
hNM : N ≤ M
ω : Ω
⊢ sSup {n | upperCrossingTime a b f N n ω < N} ≤ sSup {n | upperCrossingTime a b f M n ω < M}
state_after: case pos
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
hab : a < b
N M : ℕ
hNM : N ≤ M
ω : Ω
hemp : {n | upperCrossingTime a b f N n ω < N}.Nonempty
⊢ sSup {n | upperCrossingTime a b f N n ω < N} ≤ sSup {n | upperCrossingTime a b f M n ω < M}

case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N✝ n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
hab : a < b
N M : ℕ
hNM : N ≤ M
ω : Ω
hemp : ¬{n | upperCrossingTime a b f N n ω < N}.Nonempty
⊢ sSup {n | upperCrossingTime a b f N n ω < N} ≤ sSup {n | upperCrossingTime a b f M n ω < M}
tactic: by_cases hemp : {n : ℕ | upperCrossingTime a b f N n ω < N}.Nonempty
Theorem: ContinuousMap.sup_mem_closed_subalgebra
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ ↑f ⊔ ↑g ∈ A
state_after: case h.e'_5
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ A = A.topologicalClosure
tactic: convert sup_mem_subalgebra_closure A f g
state_before: case h.e'_5
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ A = A.topologicalClosure
state_after: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ ↑A = ↑A.topologicalClosure
tactic: apply SetLike.ext'
state_before: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ ↑A = ↑A.topologicalClosure
state_after: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ ↑A.topologicalClosure = ↑A
tactic: symm
state_before: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ ↑A.topologicalClosure = ↑A
state_after: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ IsClosed ↑A.toSubsemiring
tactic: erw [closure_eq_iff_isClosed]
state_before: case h.e'_5.h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
h : IsClosed ↑A
f g : ↥A
⊢ IsClosed ↑A.toSubsemiring
state_after: no goals
tactic: exact h
Theorem: Nat.repr_length
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n e : ℕ
⊢ 0 < e → n < 10 ^ e → n.repr.length ≤ e
state_after: no goals
tactic: cases n with
    (intro e0 he; simp only [Nat.repr, Nat.toDigits, String.length, List.asString])
  | zero => assumption
  | succ n =>
    if hterm : n.succ / 10 = 0 then
      simp only [hterm, Nat.toDigitsCore]; assumption
    else
      exact toDigitsCore_length 10 (by decide) (Nat.succ n + 1) (Nat.succ n) e he e0
Theorem: Decidable.mul_lt_mul''
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a b c d : α
inst✝³ : PosMulMono α
inst✝² : PosMulStrictMono α
inst✝¹ : MulPosStrictMono α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
h1 : a < c
h2 : b < d
h3 : 0 ≤ a
h4 : 0 ≤ b
b0 : 0 = b
⊢ a * b < c * d
state_after: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a b c d : α
inst✝³ : PosMulMono α
inst✝² : PosMulStrictMono α
inst✝¹ : MulPosStrictMono α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
h1 : a < c
h2 : b < d
h3 : 0 ≤ a
h4 : 0 ≤ b
b0 : 0 = b
⊢ 0 < c * d
tactic: rw [← b0, mul_zero]
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a b c d : α
inst✝³ : PosMulMono α
inst✝² : PosMulStrictMono α
inst✝¹ : MulPosStrictMono α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
h1 : a < c
h2 : b < d
h3 : 0 ≤ a
h4 : 0 ≤ b
b0 : 0 = b
⊢ 0 < c * d
state_after: no goals
tactic: exact mul_pos (h3.trans_lt h1) (h4.trans_lt h2)
Theorem: LinearEquiv.toSpanNonzeroSingleton_one
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✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
⊢ (toSpanNonzeroSingleton R M x h) 1 = ⟨x, ⋯⟩
state_after: no goals
tactic: simp
Theorem: Set.image_add_right
File: Mathlib/Data/Set/Pointwise/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
a b : α
⊢ (fun x => x * b) '' t = (fun x => x * b⁻¹) ⁻¹' t
state_after: no goals
tactic: rw [image_eq_preimage_of_inverse] <;> intro c <;> simp
Theorem: Polynomial.support_scaleRoots_le
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
⊢ (p.scaleRoots s).support ≤ p.support
state_after: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
a✝ : ℕ
⊢ a✝ ∈ (p.scaleRoots s).support → a✝ ∈ p.support
tactic: intro
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
s : R
a✝ : ℕ
⊢ a✝ ∈ (p.scaleRoots s).support → a✝ ∈ p.support
state_after: no goals
tactic: simpa using left_ne_zero_of_mul