ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: UniqueFactorizationMonoid.dvdNotUnit_iff_normalizedFactors_lt_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ DvdNotUnit x y ↔ normalizedFactors x < normalizedFactors y
state_after: case mp
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ DvdNotUnit x y → normalizedFactors x < normalizedFactors y

case mpr
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ normalizedFactors x < normalizedFactors y → DvdNotUnit x y
tactic: constructor
Theorem: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_f
File: Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
X₁ X₂ X₃ : ModuleCat R
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
hfg : LinearMap.range f ≤ LinearMap.ker g
⊢ f ≫ g = 0
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
X₁ X₂ X₃ : ModuleCat R
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
hfg : LinearMap.range f ≤ LinearMap.ker g
x✝ : ↑X₁
⊢ (f ≫ g) x✝ = 0 x✝
tactic: ext
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
X₁ X₂ X₃ : ModuleCat R
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
hfg : LinearMap.range f ≤ LinearMap.ker g
x✝ : ↑X₁
⊢ (f ≫ g) x✝ = 0 x✝
state_after: no goals
tactic: exact hfg ⟨_, rfl⟩
Theorem: SmoothBumpCovering.mem_chartAt_source_of_eq_one
File: Mathlib/Geometry/Manifold/PartitionOfUnity.lean

Proof steps:
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
U : M → Set M
fs : SmoothBumpCovering ι I M s
i : ι
x : M
h : ↑(fs.toFun i) x = 1
⊢ x ∈ support ↑(fs.toFun i)
state_after: no goals
tactic: simp [h]
Theorem: Multiset.prod_eq_foldl
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
s : Multiset α
x y z : α
⊢ (fun x x_1 => x * x_1) ((fun x x_1 => x * x_1) x y) z = (fun x x_1 => x * x_1) ((fun x x_1 => x * x_1) x z) y
state_after: no goals
tactic: simp [mul_right_comm]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
s : Multiset α
⊢ foldl (fun x y => y * x) ⋯ 1 s = foldl (fun x x_1 => x * x_1) ⋯ 1 s
state_after: no goals
tactic: simp [mul_comm]
Theorem: StarModule.decomposeProdAdjoint_symm_apply
File: Mathlib/Algebra/Star/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
⊢ A ≃ₗ[R] ↥(selfAdjoint A) × ↥(skewAdjoint A)
state_after: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
⊢ (selfAdjointPart R).prod (skewAdjointPart R) ∘ₗ
      (selfAdjoint.submodule R A).subtype.coprod (skewAdjoint.submodule R A).subtype =
    LinearMap.id
tactic: refine LinearEquiv.ofLinear ((selfAdjointPart R).prod (skewAdjointPart R))
    (LinearMap.coprod ((selfAdjoint.submodule R A).subtype) (skewAdjoint.submodule R A).subtype)
    ?_ (LinearMap.ext <| StarModule.selfAdjointPart_add_skewAdjointPart R)
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
⊢ (selfAdjointPart R).prod (skewAdjointPart R) ∘ₗ
      (selfAdjoint.submodule R A).subtype.coprod (skewAdjoint.submodule R A).subtype =
    LinearMap.id
state_after: no goals
tactic: ext x <;> dsimp <;> erw [Submodule.coeSubtype, Submodule.coeSubtype] <;> simp
Theorem: Quaternion.continuous_normSq
File: Mathlib/Analysis/Quaternion.lean

Proof steps:
state_before: ⊢ Continuous ⇑normSq
state_after: no goals
tactic: simpa [← normSq_eq_norm_mul_self] using
    (continuous_norm.mul continuous_norm : Continuous fun q : ℍ => ‖q‖ * ‖q‖)
Theorem: MeasureTheory.setLintegral_eq_top_of_measure_eq_top_ne_zero
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
hf : AEMeasurable f (μ.restrict s)
hμf : μ {x | x ∈ s ∧ f x = ⊤} ≠ 0
⊢ μ {x | x ∈ s ∧ f x = ⊤} ≤ (μ.restrict s) {x | f x = ⊤}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
hf : AEMeasurable f (μ.restrict s)
hμf : μ {x | x ∈ s ∧ f x = ⊤} ≠ 0
⊢ μ ({a | f a = ⊤} ∩ s) ≤ (μ.restrict s) {x | f x = ⊤}
tactic: rw [← setOf_inter_eq_sep]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
hf : AEMeasurable f (μ.restrict s)
hμf : μ {x | x ∈ s ∧ f x = ⊤} ≠ 0
⊢ μ ({a | f a = ⊤} ∩ s) ≤ (μ.restrict s) {x | f x = ⊤}
state_after: no goals
tactic: exact Measure.le_restrict_apply _ _
Theorem: MeasureTheory.ite_ae_eq_of_measure_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] g
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] g
tactic: have h_ss : sᶜ ⊆ { a : α | ite (a ∈ s) (f a) (g a) = g a } := fun x hx => by
    simp [(Set.mem_compl_iff _ _).mp hx]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] g
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ {x | (fun x => (fun x => if x ∈ s then f x else g x) x = g x) x}ᶜ ⊆ s
tactic: refine measure_mono_null ?_ hs_zero
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ {x | (fun x => (fun x => if x ∈ s then f x else g x) x = g x) x}ᶜ ⊆ s
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ {x | (fun x => (fun x => if x ∈ s then f x else g x) x = g x) x}ᶜ ⊆ sᶜᶜ
tactic: conv_rhs => rw [← compl_compl s]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ {x | (fun x => (fun x => if x ∈ s then f x else g x) x = g x) x}ᶜ ⊆ sᶜᶜ
state_after: no goals
tactic: rwa [Set.compl_subset_compl]
Theorem: Ideal.stableFiltration_N
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
I : Ideal R
N : Submodule R M
i : ℕ
⊢ (fun i => I ^ i • N) (i + 1) ≤ (fun i => I ^ i • N) i
state_after: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I ^ (i + 1) • N ≤ I ^ i • N
tactic: dsimp only
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I ^ (i + 1) • N ≤ I ^ i • N
state_after: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I ^ 1 • I ^ i • N ≤ I ^ i • N
tactic: rw [add_comm, pow_add, mul_smul]
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I ^ 1 • I ^ i • N ≤ I ^ i • N
state_after: no goals
tactic: exact Submodule.smul_le_right
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I • (fun i => I ^ i • N) i ≤ (fun i => I ^ i • N) (i + 1)
state_after: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I • I ^ i • N ≤ I ^ (i + 1) • N
tactic: dsimp only
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ : Ideal R
F F' : I✝.Filtration M
I : Ideal R
N : Submodule R M
i : ℕ
⊢ I • I ^ i • N ≤ I ^ (i + 1) • N
state_after: no goals
tactic: rw [add_comm, pow_add, mul_smul, pow_one]
Theorem: Equiv.prodShear_symm_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
⊢ LeftInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2)
state_after: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₁
y₁ : β₁
⊢ (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) ((fun x => (e₁ x.1, (e₂ x.1) x.2)) (x₁, y₁)) = (x₁, y₁)
tactic: rintro ⟨x₁, y₁⟩
state_before: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₁
y₁ : β₁
⊢ (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) ((fun x => (e₁ x.1, (e₂ x.1) x.2)) (x₁, y₁)) = (x₁, y₁)
state_after: no goals
tactic: simp only [symm_apply_apply]
state_before: α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
⊢ Function.RightInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2)
state_after: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₂
y₁ : β₂
⊢ (fun x => (e₁ x.1, (e₂ x.1) x.2)) ((fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) (x₁, y₁)) = (x₁, y₁)
tactic: rintro ⟨x₁, y₁⟩
state_before: case mk
α₁ : Type ?u.41768
β₁ : Type ?u.41767
β₂ : Type ?u.41769
e : α₁ → β₁ ≃ β₂
α₂ : Type ?u.41770
e₁ : α₁ ≃ α₂
e₂ : α₁ → β₁ ≃ β₂
x₁ : α₂
y₁ : β₂
⊢ (fun x => (e₁ x.1, (e₂ x.1) x.2)) ((fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) (x₁, y₁)) = (x₁, y₁)
state_after: no goals
tactic: simp only [apply_symm_apply]
Theorem: floorDiv_zero
File: Mathlib/Algebra/Order/Floor/Div.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : SMulZeroClass α β
inst✝ : FloorDiv α β
a : α
b✝ c b : β
⊢ b ⌊/⌋ 0 = 0
state_after: no goals
tactic: simp
Theorem: CochainComplex.mappingCone.inr_f_snd_v
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.23583, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p : ℤ
⊢ (inr φ).f p ≫ (snd φ).v p p ⋯ = 𝟙 (G.X p)
state_after: no goals
tactic: simp [inr, snd]
Theorem: MeasureTheory.ProbabilityMeasure.ennreal_coeFn_eq_coeFn_toMeasure
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
ν : ProbabilityMeasure Ω
s : Set Ω
⊢ ↑(ν s) = ↑ν s
state_after: no goals
tactic: rw [← coeFn_comp_toFiniteMeasure_eq_coeFn, FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure,
    toMeasure_comp_toFiniteMeasure_eq_toMeasure]
Theorem: Measurable.ennreal_tsum
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ∑' (i : ι), f i x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ⨆ s, ∑ i ∈ s, f i x
tactic: simp_rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ⨆ s, ∑ i ∈ s, f i x
state_after: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ ∀ (i : Finset ι), Measurable fun b => ∑ i ∈ i, f i b
tactic: apply measurable_iSup
state_before: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ ∀ (i : Finset ι), Measurable fun b => ∑ i ∈ i, f i b
state_after: no goals
tactic: exact fun s => s.measurable_sum fun i _ => h i
Theorem: CategoryTheory.MorphismProperty.LeftFraction.Localization.map_eq_iff
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.98000, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f g : W.LeftFraction X Y
⊢ f.map (Q W) ⋯ = g.map (Q W) ⋯ ↔ LeftFractionRel f g
state_after: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.98000, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f g : W.LeftFraction X Y
⊢ (Hom.mk f).map (Q W) ⋯ = (Hom.mk g).map (Q W) ⋯ ↔ LeftFractionRel f g
tactic: simp only [← Hom.map_mk _ (Q W)]
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.98000, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f g : W.LeftFraction X Y
⊢ (Hom.mk f).map (Q W) ⋯ = (Hom.mk g).map (Q W) ⋯ ↔ LeftFractionRel f g
state_after: case mp
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.98000, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f g : W.LeftFraction X Y
⊢ (Hom.mk f).map (Q W) ⋯ = (Hom.mk g).map (Q W) ⋯ → LeftFractionRel f g

case mpr
C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{?u.98000, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y : C
f g : W.LeftFraction X Y
⊢ LeftFractionRel f g → (Hom.mk f).map (Q W) ⋯ = (Hom.mk g).map (Q W) ⋯
tactic: constructor
Theorem: mul_inv_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * b⁻¹ = c
⊢ a = c * b
state_after: no goals
tactic: rw [← h, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = c * b
⊢ a * b⁻¹ = c
state_after: no goals
tactic: rw [h, mul_inv_cancel_right]
Theorem: Function.support_div
File: Mathlib/Algebra/GroupWithZero/Indicator.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
G₀ : Type u_3
M₀ : Type u_4
R : Type u_5
inst✝ : GroupWithZero G₀
f g : ι → G₀
⊢ (support fun a => f a / g a) = support f ∩ support g
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Primrec.nat_omega_rec
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
m : α → β → ℕ
l : α → β → List β
g : α → β × List σ → Option σ
hm : Primrec₂ m
hl : Primrec₂ l
hg : Primrec₂ g
Ord : ∀ (a : α) (b b' : β), b' ∈ l a b → m a b' < m a b
H : ∀ (a : α) (b : β), g a (b, List.map (f a) (l a b)) = some (f a b)
⊢ ∀ (b b' : α × β), b' ∈ List.map (fun b_1 => (b.1, b_1)) (l b.1 b.2) → uncurry m b' < uncurry m b
state_after: no goals
tactic: simpa using Ord
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β → σ
m : α → β → ℕ
l : α → β → List β
g : α → β × List σ → Option σ
hm : Primrec₂ m
hl : Primrec₂ l
hg : Primrec₂ g
Ord : ∀ (a : α) (b b' : β), b' ∈ l a b → m a b' < m a b
H : ∀ (a : α) (b : β), g a (b, List.map (f a) (l a b)) = some (f a b)
⊢ ∀ (b : α × β), g b.1 (b.2, List.map (uncurry f) (List.map (fun b_1 => (b.1, b_1)) (l b.1 b.2))) = some (uncurry f b)
state_after: no goals
tactic: simpa [Function.comp] using H
Theorem: groupCohomology.shortComplexH0_exact
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ (shortComplexH0 A).Exact
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ∀ (x₂ : ↑(shortComplexH0 A).X₂), (shortComplexH0 A).g x₂ = 0 → ∃ x₁, (shortComplexH0 A).f x₁ = x₂
tactic: rw [ShortComplex.moduleCat_exact_iff]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ∀ (x₂ : ↑(shortComplexH0 A).X₂), (shortComplexH0 A).g x₂ = 0 → ∃ x₁, (shortComplexH0 A).f x₁ = x₂
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
⊢ ∃ x₁, (shortComplexH0 A).f x₁ = x
tactic: intro (x : A) (hx : dZero _ x = 0)
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
⊢ ∃ x₁, (shortComplexH0 A).f x₁ = x
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x = x
tactic: refine ⟨⟨x, fun g => ?_⟩, rfl⟩
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x = x
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x - x = 0
tactic: rw [← sub_eq_zero]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x : CoeSort.coe A
hx : (dZero A) x = 0
g : G
⊢ (A.ρ g) x - x = 0
state_after: no goals
tactic: exact congr_fun hx g
Theorem: dist_mul_self_left
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedGroup E
inst✝ : SeminormedGroup F
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist (a * b) b = ‖a‖
state_after: no goals
tactic: rw [dist_comm, dist_mul_self_right]
Theorem: Basis.det_map
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
A : Type u_5
inst✝¹ : CommRing A
inst✝ : Module A M
b : Basis ι R M
f : M ≃ₗ[R] M'
v : ι → M'
⊢ (b.map f).det v = b.det (⇑f.symm ∘ v)
state_after: no goals
tactic: rw [Basis.det_apply, Basis.toMatrix_map, Basis.det_apply]
Theorem: EMetric.tendstoUniformlyOn_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
⊢ TendstoUniformlyOn F f p s ↔ ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
state_after: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
tactic: refine ⟨fun H ε hε => H _ (edist_mem_uniformity hε), fun H u hu => ?_⟩
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
state_after: case intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ≥0∞
εpos : ε > 0
hε : ∀ {a b : α}, edist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
tactic: rcases mem_uniformity_edist.1 hu with ⟨ε, εpos, hε⟩
state_before: case intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
ι : Type u_2
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ ε > 0, ∀ᶠ (n : ι) in p, ∀ x ∈ s, edist (f x) (F n x) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
ε : ℝ≥0∞
εpos : ε > 0
hε : ∀ {a b : α}, edist a b < ε → (a, b) ∈ u
⊢ ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u
state_after: no goals
tactic: exact (H ε εpos).mono fun n hs x hx => hε (hs x hx)