ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Monotone.map_csSup_of_continuousAt
File: Mathlib/Topology/Order/Monotone.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : s.Nonempty
H : BddAbove s
⊢ f (sSup s) = sSup (f '' s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : s.Nonempty
H : BddAbove s
⊢ IsLUB (f '' s) (f (sSup s))
tactic: refine ((isLUB_csSup (ne.image f) (Mf.map_bddAbove H)).unique ?_).symm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : s.Nonempty
H : BddAbove s
⊢ IsLUB (f '' s) (f (sSup s))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : s.Nonempty
H : BddAbove s
⊢ Tendsto f (𝓝[s] sSup s) (𝓝 (f (sSup s)))
tactic: refine (isLUB_csSup ne H).isLUB_of_tendsto (fun x _ y _ xy => Mf xy) ne ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderClosedTopology β
inst✝ : Nonempty γ
f : α → β
s : Set α
Cf : ContinuousAt f (sSup s)
Mf : Monotone f
ne : s.Nonempty
H : BddAbove s
⊢ Tendsto f (𝓝[s] sSup s) (𝓝 (f (sSup s)))
state_after: no goals
tactic: exact Cf.mono_left inf_le_left
Theorem: ENNReal.div_lt_of_lt_mul'
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a < b * c
⊢ a < c * b
state_after: no goals
tactic: rwa [mul_comm]
Theorem: SimpleGraph.Subgraph.connected_iff_forall_exists_walk_subgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
⊢ H.Connected ↔ H.verts.Nonempty ∧ ∀ {u v : V}, u ∈ H.verts → v ∈ H.verts → ∃ p, p.toSubgraph ≤ H
state_after: no goals
tactic: rw [H.connected_iff, preconnected_iff_forall_exists_walk_subgraph, and_comm]
Theorem: Irrational.of_int_sub
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
m : ℤ
h : Irrational (↑m - x)
⊢ Irrational (↑↑m - x)
state_after: no goals
tactic: rwa [Rat.cast_intCast]
Theorem: SimpleGraph.Subgraph.preconnected_iff_forall_exists_walk_subgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
⊢ H.Preconnected ↔ ∀ {u v : V}, u ∈ H.verts → v ∈ H.verts → ∃ p, p.toSubgraph ≤ H
state_after: case mp
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
⊢ H.Preconnected → ∀ {u v : V}, u ∈ H.verts → v ∈ H.verts → ∃ p, p.toSubgraph ≤ H

case mpr
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
⊢ (∀ {u v : V}, u ∈ H.verts → v ∈ H.verts → ∃ p, p.toSubgraph ≤ H) → H.Preconnected
tactic: constructor
Theorem: Submodule.iSup_dualAnnihilator_le_iInf
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Sort u_1
U : ι → Submodule R M
⊢ ⨆ i, (U i).dualAnnihilator ≤ (⨅ i, U i).dualAnnihilator
state_after: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Sort u_1
U : ι → Submodule R M
⊢ ⨅ i, U i ≤ ⨅ i, (U i).dualAnnihilator.dualCoannihilator
tactic: rw [le_dualAnnihilator_iff_le_dualCoannihilator, dualCoannihilator_iSup_eq]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Sort u_1
U : ι → Submodule R M
⊢ ⨅ i, U i ≤ ⨅ i, (U i).dualAnnihilator.dualCoannihilator
state_after: case h
R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Sort u_1
U : ι → Submodule R M
⊢ ∀ (i : ι), U i ≤ (U i).dualAnnihilator.dualCoannihilator
tactic: apply iInf_mono
state_before: case h
R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Sort u_1
U : ι → Submodule R M
⊢ ∀ (i : ι), U i ≤ (U i).dualAnnihilator.dualCoannihilator
state_after: no goals
tactic: exact fun i : ι => le_dualAnnihilator_dualCoannihilator (U i)
Theorem: NumberField.ComplexEmbedding.IsConj.isReal_comp
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: K : Type u_1
inst✝² : Field K
k : Type u_2
inst✝¹ : Field k
inst✝ : Algebra k K
φ : K →+* ℂ
σ : K ≃ₐ[k] K
h : IsConj φ σ
⊢ IsReal (φ.comp (algebraMap k K))
state_after: case a
K : Type u_1
inst✝² : Field K
k : Type u_2
inst✝¹ : Field k
inst✝ : Algebra k K
φ : K →+* ℂ
σ : K ≃ₐ[k] K
h : IsConj φ σ
x : k
⊢ (star (φ.comp (algebraMap k K))) x = (φ.comp (algebraMap k K)) x
tactic: ext1 x
state_before: case a
K : Type u_1
inst✝² : Field K
k : Type u_2
inst✝¹ : Field k
inst✝ : Algebra k K
φ : K →+* ℂ
σ : K ≃ₐ[k] K
h : IsConj φ σ
x : k
⊢ (star (φ.comp (algebraMap k K))) x = (φ.comp (algebraMap k K)) x
state_after: no goals
tactic: simp only [conjugate_coe_eq, RingHom.coe_comp, Function.comp_apply, ← h.eq,
    starRingEnd_apply, AlgEquiv.commutes]
Theorem: sup_inf_self
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Lattice α
a b c d : α
⊢ a ⊔ a ⊓ b = a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Functor.preservesEpimorphsisms_of_adjunction
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
⊢ ∀ {Z : D} (g h : F.obj Y ⟶ Z), F.map f ≫ g = F.map f ≫ h → g = h
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
Z : D
g h : F.obj Y ⟶ Z
H : F.map f ≫ g = F.map f ≫ h
⊢ g = h
tactic: intro Z g h H
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
Z : D
g h : F.obj Y ⟶ Z
H : F.map f ≫ g = F.map f ≫ h
⊢ g = h
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
Z : D
g h : F.obj Y ⟶ Z
H : (adj.homEquiv X Z) (F.map f ≫ g) = (adj.homEquiv X Z) (F.map f ≫ h)
⊢ g = h
tactic: replace H := congr_arg (adj.homEquiv X Z) H
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X Y : C
f : X ⟶ Y
hf : Epi f
Z : D
g h : F.obj Y ⟶ Z
H : (adj.homEquiv X Z) (F.map f ≫ g) = (adj.homEquiv X Z) (F.map f ≫ h)
⊢ g = h
state_after: no goals
tactic: rwa [adj.homEquiv_naturality_left, adj.homEquiv_naturality_left, cancel_epi,
          Equiv.apply_eq_iff_eq] at H
Theorem: Set.pairwiseDisjoint_filter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t : Finset α
⊢ s.PairwiseDisjoint fun x => filter (fun x_1 => f x_1 = x) t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t : Finset α
i j : β
h : i ≠ j
u : Finset α
hi : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) i
hj : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) j
x : α
hx : x ∈ u
⊢ x ∈ ⊥
tactic: rintro i - j - h u hi hj x hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t : Finset α
i j : β
h : i ≠ j
u : Finset α
hi : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) i
hj : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) j
x : α
hx : x ∈ u
⊢ x ∈ ⊥
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t : Finset α
j : β
u : Finset α
hj : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) j
x : α
hx : x ∈ u
h : f x ≠ j
hi : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) (f x)
⊢ x ∈ ⊥
tactic: obtain ⟨-, rfl⟩ : x ∈ t ∧ f x = i := by simpa using hi hx
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t : Finset α
j : β
u : Finset α
hj : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) j
x : α
hx : x ∈ u
h : f x ≠ j
hi : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) (f x)
⊢ x ∈ ⊥
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t u : Finset α
x : α
hx : x ∈ u
hi hj : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) (f x)
h : f x ≠ f x
⊢ x ∈ ⊥
tactic: obtain ⟨-, rfl⟩ : x ∈ t ∧ f x = j := by simpa using hj hx
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq β
f : α → β
s : Set β
t u : Finset α
x : α
hx : x ∈ u
hi hj : u ≤ (fun x => filter (fun x_1 => f x_1 = x) t) (f x)
h : f x ≠ f x
⊢ x ∈ ⊥
state_after: no goals
tactic: contradiction
Theorem: Matrix.conjTranspose_fromRows_eq_fromColumns_conjTranspose
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Star R
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
⊢ (A₁.fromRows A₂)ᴴ = A₁ᴴ.fromColumns A₂ᴴ
state_after: no goals
tactic: ext _ (_ | _) <;> simp
Theorem: MeasureTheory.ProbabilityMeasure.tendsto_map_of_tendsto_of_continuous
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

Proof steps:
state_before: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
ι : Type u_3
L : Filter ι
νs : ι → ProbabilityMeasure Ω
ν : ProbabilityMeasure Ω
lim : Tendsto νs L (𝓝 ν)
f : Ω → Ω'
f_cont : Continuous f
⊢ Tendsto (fun i => (νs i).map ⋯) L (𝓝 (ν.map ⋯))
state_after: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
ι : Type u_3
L : Filter ι
νs : ι → ProbabilityMeasure Ω
ν : ProbabilityMeasure Ω
lim : ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(νs i)) L (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑ν))
f : Ω → Ω'
f_cont : Continuous f
⊢ ∀ (f_1 : Ω' →ᵇ ℝ≥0),
    Tendsto (fun i => ∫⁻ (ω : Ω'), ↑(f_1 ω) ∂↑((νs i).map ⋯)) L (𝓝 (∫⁻ (ω : Ω'), ↑(f_1 ω) ∂↑(ν.map ⋯)))
tactic: rw [ProbabilityMeasure.tendsto_iff_forall_lintegral_tendsto] at lim ⊢
state_before: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
ι : Type u_3
L : Filter ι
νs : ι → ProbabilityMeasure Ω
ν : ProbabilityMeasure Ω
lim : ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(νs i)) L (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑ν))
f : Ω → Ω'
f_cont : Continuous f
⊢ ∀ (f_1 : Ω' →ᵇ ℝ≥0),
    Tendsto (fun i => ∫⁻ (ω : Ω'), ↑(f_1 ω) ∂↑((νs i).map ⋯)) L (𝓝 (∫⁻ (ω : Ω'), ↑(f_1 ω) ∂↑(ν.map ⋯)))
state_after: Ω : Type u_1
Ω' : Type u_2
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : MeasurableSpace Ω'
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω'
inst✝ : BorelSpace Ω'
ι : Type u_3
L : Filter ι
νs : ι → ProbabilityMeasure Ω
ν : ProbabilityMeasure Ω
lim : ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(νs i)) L (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑ν))
f : Ω → Ω'
f_cont : Continuous f
g : Ω' →ᵇ ℝ≥0
⊢ Tendsto (fun i => ∫⁻ (ω : Ω'), ↑(g ω) ∂↑((νs i).map ⋯)) L (𝓝 (∫⁻ (ω : Ω'), ↑(g ω) ∂↑(ν.map ⋯)))
tactic: intro g
Theorem: Fin.foldl_loop_eq
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: α : Sort u_1
n : Nat
f : α → Fin n → α
x : α
⊢ foldl.loop n f x n = x
state_after: no goals
tactic: rw [foldl.loop, dif_neg (Nat.lt_irrefl _)]
Theorem: contDiff_iff_contDiffAt
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiff 𝕜 n f ↔ ∀ (x : E), ContDiffAt 𝕜 n f x
state_after: no goals
tactic: simp [← contDiffOn_univ, ContDiffOn, ContDiffAt]
Theorem: Submodule.mem_span_insert
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
y : M
⊢ x ∈ span R (insert y s) ↔ ∃ a, ∃ z ∈ span R s, x = a • y + z
state_after: no goals
tactic: simp [span_insert, mem_sup, mem_span_singleton, eq_comm (a := x)]
Theorem: Submodule.IsPrincipal.generator_submoduleImage_dvd_of_mem
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
N O : Submodule R M
hNO : N ≤ O
ϕ : ↥O →ₗ[R] R
inst✝ : (ϕ.submoduleImage N).IsPrincipal
x : M
hx : x ∈ N
⊢ generator (ϕ.submoduleImage N) ∣ ϕ ⟨x, ⋯⟩
state_after: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
N O : Submodule R M
hNO : N ≤ O
ϕ : ↥O →ₗ[R] R
inst✝ : (ϕ.submoduleImage N).IsPrincipal
x : M
hx : x ∈ N
⊢ ∃ y, ∃ (yN : y ∈ N), ϕ ⟨y, ⋯⟩ = ϕ ⟨x, ⋯⟩
tactic: rw [← mem_iff_generator_dvd, LinearMap.mem_submoduleImage_of_le hNO]
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : CommRing R
inst✝¹ : Module R M
N O : Submodule R M
hNO : N ≤ O
ϕ : ↥O →ₗ[R] R
inst✝ : (ϕ.submoduleImage N).IsPrincipal
x : M
hx : x ∈ N
⊢ ∃ y, ∃ (yN : y ∈ N), ϕ ⟨y, ⋯⟩ = ϕ ⟨x, ⋯⟩
state_after: no goals
tactic: exact ⟨x, hx, rfl⟩
Theorem: CategoryTheory.Functor.mapArrow_map_right
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
state_after: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : (𝟭 C).map f.left ≫ Y✝.hom = X✝.hom ≫ (𝟭 C).map f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
tactic: let w := f.w
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : (𝟭 C).map f.left ≫ Y✝.hom = X✝.hom ≫ (𝟭 C).map f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
state_after: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
tactic: simp only [id_map] at w
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
state_after: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ F.map f.left ≫ F.map Y✝.hom = F.map X✝.hom ≫ F.map f.right
tactic: dsimp
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ F.map f.left ≫ F.map Y✝.hom = F.map X✝.hom ≫ F.map f.right
state_after: no goals
tactic: simp only [← F.map_comp, w]
Theorem: Nat.Primrec.id
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: n : ℕ
⊢ Nat.pair (unpair n).1 (unpair n).2 = id n
state_after: no goals
tactic: simp
Theorem: Nat.fib_le_fib_succ
File: Mathlib/Data/Nat/Fib/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ fib n ≤ fib (n + 1)
state_after: no goals
tactic: cases n <;> simp [fib_add_two]
Theorem: Finset.pimage_empty
File: Mathlib/Data/Finset/PImage.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b : β
⊢ pimage f ∅ = ∅
state_after: case a
α : Type u_1
β : Type u_2
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b a✝ : β
⊢ a✝ ∈ pimage f ∅ ↔ a✝ ∈ ∅
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
inst✝² : DecidableEq β
f g : α →. β
inst✝¹ : (x : α) → Decidable (f x).Dom
inst✝ : (x : α) → Decidable (g x).Dom
s t : Finset α
b a✝ : β
⊢ a✝ ∈ pimage f ∅ ↔ a✝ ∈ ∅
state_after: no goals
tactic: simp
Theorem: Complex.hasDerivAt_logTaylor
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: n : ℕ
z : ℂ
⊢ HasDerivAt (logTaylor (n + 1)) (∑ j ∈ Finset.range n, (-1) ^ j * z ^ j) z
state_after: no goals
tactic: induction n with
  | zero => simp [logTaylor_succ, logTaylor_zero, Pi.add_def, hasDerivAt_const]
  | succ n ih =>
    rw [logTaylor_succ]
    simp only [cpow_natCast, Nat.cast_add, Nat.cast_one, Nat.odd_iff_not_even,
      Finset.sum_range_succ, (show (-1) ^ (n + 1 + 1) = (-1) ^ n by ring)]
    refine HasDerivAt.add ih ?_
    simp only [Nat.odd_iff_not_even, Int.cast_pow, Int.cast_neg, Int.cast_one, mul_div_assoc]
    have : HasDerivAt (fun x : ℂ ↦ (x ^ (n + 1) / (n + 1))) (z ^ n) z := by
      simp_rw [div_eq_mul_inv]
      convert HasDerivAt.mul_const (hasDerivAt_pow (n + 1) z) (((n : ℂ) + 1)⁻¹) using 1
      field_simp [Nat.cast_add_one_ne_zero n]
    convert HasDerivAt.const_mul _ this using 2
    ring
Theorem: threeGPFree_smul_set
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : ThreeGPFree (a • s)
b : α
hb : b ∈ s
c : α
hc : c ∈ s
d : α
hd : d ∈ s
h : b * d = c * c
⊢ a • b * a • d = a * c * (a * c)
state_after: no goals
tactic: rw [mul_mul_mul_comm, smul_eq_mul, smul_eq_mul, mul_mul_mul_comm, h]
Theorem: norm_smul_inv_norm'
File: Mathlib/Analysis/NormedSpace/RCLike.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_nonneg : 0 ≤ r
x : E
hx : x ≠ 0
⊢ ‖(↑r * (↑‖x‖)⁻¹) • x‖ = r
state_after: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_nonneg : 0 ≤ r
x : E
hx : x ≠ 0
this : ‖x‖ ≠ 0
⊢ ‖(↑r * (↑‖x‖)⁻¹) • x‖ = r
tactic: have : ‖x‖ ≠ 0 := by simp [hx]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
r_nonneg : 0 ≤ r
x : E
hx : x ≠ 0
this : ‖x‖ ≠ 0
⊢ ‖(↑r * (↑‖x‖)⁻¹) • x‖ = r
state_after: no goals
tactic: field_simp [norm_smul, r_nonneg, rclike_simps]
Theorem: Matroid.comapOn_base_iff_of_bijOn
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ (N.comapOn E f).Base B ↔ N.Base (f '' B) ∧ B ⊆ E
state_after: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ B ⊆ E → ((N.comapOn E f).Base B ↔ N.Base (f '' B))
tactic: rw [← and_iff_left_of_imp (Base.subset_ground (M := N.comapOn E f) (B := B)),
    comapOn_ground_eq, and_congr_left_iff]
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ B ⊆ E → ((N.comapOn E f).Base B ↔ N.Base (f '' B))
state_after: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ B ⊆ E → InjOn f B
tactic: suffices h' : B ⊆ E → InjOn f B from fun hB ↦
    by simp [hB, comapOn_base_iff_of_surjOn h.surjOn, h']
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : BijOn f E N.E
⊢ B ⊆ E → InjOn f B
state_after: no goals
tactic: exact fun hBE ↦ h.injOn.mono hBE
Theorem: round_int_add
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
y : ℤ
⊢ round (↑y + x) = y + round x
state_after: no goals
tactic: rw [add_comm, round_add_int, add_comm]