ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ComposableArrows.sc'MapIso_hom
File: Mathlib/Algebra/Homology/ExactSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.36849, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : S₁.IsComplex
h₂ : S₂.IsComplex
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ sc'Map e.hom h₁ h₂ i j k ⋯ ⋯ ⋯ ≫ sc'Map e.inv h₂ h₁ i j k ⋯ ⋯ ⋯ = 𝟙 (S₁.sc' h₁ i j k ⋯ ⋯ ⋯)
state_after: no goals
tactic: ext <;> dsimp <;> simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.36849, u_1} C
inst✝ : HasZeroMorphisms C
n : ℕ
S S₁ S₂ : ComposableArrows C n
e : S₁ ≅ S₂
h₁ : S₁.IsComplex
h₂ : S₂.IsComplex
i j k : ℕ
hij : autoParam (i + 1 = j) _auto✝
hjk : autoParam (j + 1 = k) _auto✝
hk : autoParam (k ≤ n) _auto✝
⊢ sc'Map e.inv h₂ h₁ i j k ⋯ ⋯ ⋯ ≫ sc'Map e.hom h₁ h₂ i j k ⋯ ⋯ ⋯ = 𝟙 (S₂.sc' h₂ i j k ⋯ ⋯ ⋯)
state_after: no goals
tactic: ext <;> dsimp <;> simp
Theorem: String.data_dropWhile
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: p : Char → Bool
s : String
⊢ (s.dropWhile p).data = List.dropWhile p s.data
state_after: no goals
tactic: rw [dropWhile_eq]
Theorem: LinearMap.BilinForm.isAdjointPair_unique_of_nondegenerate
File: Mathlib/LinearAlgebra/BilinearForm/Properties.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : CommSemiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹¹ : CommRing R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁸ : Field K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
M'✝ : Type u_7
M'' : Type u_8
inst✝⁵ : AddCommMonoid M'✝
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M'✝
inst✝² : Module R M''
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M' : Type u_9
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R₁ M₁
b : B.Nondegenerate
φ ψ₁ ψ₂ : M₁ →ₗ[R₁] M₁
hψ₁ : B.IsAdjointPair B ψ₁ φ
hψ₂ : B.IsAdjointPair B ψ₂ φ
v w : M₁
⊢ ((B.compLeft ψ₁) v) w = ((B.compLeft ψ₂) v) w
state_after: no goals
tactic: rw [compLeft_apply, compLeft_apply, hψ₁, hψ₂]
Theorem: CategoryTheory.Limits.IsImage.isoExt_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF.lift F' ≫ hF'.lift F) ≫ F.m = 𝟙 F.I ≫ F.m
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF'.lift F ≫ hF.lift F') ≫ F'.m = 𝟙 F'.I ≫ F'.m
state_after: no goals
tactic: simp
Theorem: MeasureTheory.setLIntegral_subtype
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 α
s : Set α
hs : MeasurableSet s
t : Set ↑s
f : α → ℝ≥0∞
⊢ ∫⁻ (x : ↑s) in t, f ↑x ∂Measure.comap Subtype.val μ = ∫⁻ (x : α) in Subtype.val '' t, f x ∂μ
state_after: no goals
tactic: rw [(MeasurableEmbedding.subtype_coe hs).restrict_comap, lintegral_subtype_comap hs,
    restrict_restrict hs, inter_eq_right.2 (Subtype.coe_image_subset _ _)]
Theorem: Set.Ioc_diff_Ioi
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ ∀ (x : α), x ∈ Ioc a b \ Ioi c ↔ x ∈ Ioc a (min b c)
state_after: no goals
tactic: simp (config := { contextual := true }) [iff_def]
Theorem: QPF.Fix.mk_dest
File: Mathlib/Data/QPF/Univariate/Basic.lean

Proof steps:
state_before: F : Type u → Type u
q : QPF F
x : Fix F
⊢ mk x.dest = x
state_after: F : Type u → Type u
q : QPF F
x : Fix F
⊢ (mk ∘ dest) x = id x
tactic: change (Fix.mk ∘ Fix.dest) x = id x
state_before: F : Type u → Type u
q : QPF F
x : Fix F
⊢ (mk ∘ dest) x = id x
state_after: case h
F : Type u → Type u
q : QPF F
x : Fix F
⊢ ∀ (x : F (Fix F)), (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)
tactic: apply Fix.ind_rec (mk ∘ dest) id
state_before: case h
F : Type u → Type u
q : QPF F
x : Fix F
⊢ ∀ (x : F (Fix F)), (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)
state_after: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)
tactic: intro x
state_before: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)
state_after: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ mk <$> rec (Functor.map mk) <$> x = x → mk (mk <$> rec (Functor.map mk) <$> x) = mk x
tactic: rw [Function.comp_apply, id_eq, Fix.dest, Fix.rec_eq, id_map, comp_map]
state_before: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ mk <$> rec (Functor.map mk) <$> x = x → mk (mk <$> rec (Functor.map mk) <$> x) = mk x
state_after: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
h : mk <$> rec (Functor.map mk) <$> x = x
⊢ mk (mk <$> rec (Functor.map mk) <$> x) = mk x
tactic: intro h
state_before: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
h : mk <$> rec (Functor.map mk) <$> x = x
⊢ mk (mk <$> rec (Functor.map mk) <$> x) = mk x
state_after: no goals
tactic: rw [h]
Theorem: div_le_one
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ a / b ≤ 1 ↔ a ≤ b
state_after: no goals
tactic: rw [div_le_iff hb, one_mul]
Theorem: Real.toNNReal_le_toNNReal_iff
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r p : ℝ
hp : 0 ≤ p
⊢ r.toNNReal ≤ p.toNNReal ↔ r ≤ p
state_after: no goals
tactic: simp [← NNReal.coe_le_coe, hp]
Theorem: UniformSpace.Completion.dist_self
File: Mathlib/Topology/MetricSpace/Completion.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ dist x x = 0
state_after: case refine_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ IsClosed {a | dist a a = 0}

case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ ∀ (a : α), dist (↑α a) (↑α a) = 0
tactic: refine induction_on x ?_ ?_
Theorem: IsSubmonoid.image
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Monoid M
s✝ : Set M
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_3
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
s : Set M
hs : IsSubmonoid s
a b : γ
x✝¹ : a ∈ f '' s
x✝ : b ∈ f '' s
x : M
hx : x ∈ s ∧ f x = a
y : M
hy : y ∈ s ∧ f y = b
⊢ f (x * y) = a * b
state_after: no goals
tactic: rw [hf.map_mul, hx.2, hy.2]
Theorem: DiscreteQuotient.exists_of_compat
File: Mathlib/Topology/DiscreteQuotient.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : CompactSpace X
Qs : (Q : DiscreteQuotient X) → Quotient Q.toSetoid
compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs A) = Qs B
⊢ ∃ x, ∀ (Q : DiscreteQuotient X), Q.proj x = Qs Q
state_after: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : CompactSpace X
Qs : (Q : DiscreteQuotient X) → Quotient Q.toSetoid
compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs A) = Qs B
H₁ : ∀ (Q₁ Q₂ : DiscreteQuotient X), Q₁ ≤ Q₂ → Q₁.proj ⁻¹' {Qs Q₁} ⊆ Q₂.proj ⁻¹' {Qs Q₂}
⊢ ∃ x, ∀ (Q : DiscreteQuotient X), Q.proj x = Qs Q
tactic: have H₁ : ∀ Q₁ Q₂, Q₁ ≤ Q₂ → proj Q₁ ⁻¹' {Qs Q₁} ⊆ proj Q₂ ⁻¹' {Qs Q₂} := fun _ _ h => by
    rw [← compat _ _ h]
    exact fiber_subset_ofLE _ _
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : CompactSpace X
Qs : (Q : DiscreteQuotient X) → Quotient Q.toSetoid
compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs A) = Qs B
H₁ : ∀ (Q₁ Q₂ : DiscreteQuotient X), Q₁ ≤ Q₂ → Q₁.proj ⁻¹' {Qs Q₁} ⊆ Q₂.proj ⁻¹' {Qs Q₂}
⊢ ∃ x, ∀ (Q : DiscreteQuotient X), Q.proj x = Qs Q
state_after: case intro
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : CompactSpace X
Qs : (Q : DiscreteQuotient X) → Quotient Q.toSetoid
compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs A) = Qs B
H₁ : ∀ (Q₁ Q₂ : DiscreteQuotient X), Q₁ ≤ Q₂ → Q₁.proj ⁻¹' {Qs Q₁} ⊆ Q₂.proj ⁻¹' {Qs Q₂}
x : X
hx : x ∈ ⋂ Q, Q.proj ⁻¹' {Qs Q}
⊢ ∃ x, ∀ (Q : DiscreteQuotient X), Q.proj x = Qs Q
tactic: obtain ⟨x, hx⟩ : Set.Nonempty (⋂ Q, proj Q ⁻¹' {Qs Q}) :=
    IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed
      (fun Q : DiscreteQuotient X => Q.proj ⁻¹' {Qs _}) (directed_of_isDirected_ge H₁)
      (fun Q => (singleton_nonempty _).preimage Q.proj_surjective)
      (fun Q => (Q.isClosed_preimage {Qs _}).isCompact) fun Q => Q.isClosed_preimage _
state_before: case intro
α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
S : DiscreteQuotient X
inst✝ : CompactSpace X
Qs : (Q : DiscreteQuotient X) → Quotient Q.toSetoid
compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs A) = Qs B
H₁ : ∀ (Q₁ Q₂ : DiscreteQuotient X), Q₁ ≤ Q₂ → Q₁.proj ⁻¹' {Qs Q₁} ⊆ Q₂.proj ⁻¹' {Qs Q₂}
x : X
hx : x ∈ ⋂ Q, Q.proj ⁻¹' {Qs Q}
⊢ ∃ x, ∀ (Q : DiscreteQuotient X), Q.proj x = Qs Q
state_after: no goals
tactic: exact ⟨x, mem_iInter.1 hx⟩
Theorem: Equiv.toPartialEquiv_target
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e' : PartialEquiv β γ
e : α ≃ β
⊢ ⇑e '' univ = univ
state_after: no goals
tactic: rw [image_univ, e.surjective.range_eq]
Theorem: of_quotient_center_nilpotent
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
h : Group.IsNilpotent (G ⧸ center G)
⊢ Group.IsNilpotent G
state_after: case intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
h : Group.IsNilpotent (G ⧸ center G)
n : ℕ
hn : upperCentralSeries (G ⧸ center G) n = ⊤
⊢ Group.IsNilpotent G
tactic: obtain ⟨n, hn⟩ := h.nilpotent
state_before: case intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
h : Group.IsNilpotent (G ⧸ center G)
n : ℕ
hn : upperCentralSeries (G ⧸ center G) n = ⊤
⊢ Group.IsNilpotent G
state_after: case h
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
h : Group.IsNilpotent (G ⧸ center G)
n : ℕ
hn : upperCentralSeries (G ⧸ center G) n = ⊤
⊢ upperCentralSeries G n.succ = ⊤
tactic: use n.succ
state_before: case h
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
h : Group.IsNilpotent (G ⧸ center G)
n : ℕ
hn : upperCentralSeries (G ⧸ center G) n = ⊤
⊢ upperCentralSeries G n.succ = ⊤
state_after: no goals
tactic: simp [← comap_upperCentralSeries_quotient_center, hn]
Theorem: cfc_comp_pow
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : CommSemiring R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
inst✝ : UniqueContinuousFunctionalCalculus R A
f : R → R
n : ℕ
a : A
hf : autoParam (ContinuousOn f ((fun x => x ^ n) '' spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f (x ^ n)) a = cfc f (a ^ n)
state_after: no goals
tactic: rw [cfc_comp' .., cfc_pow_id ..]
Theorem: Rat.cast_pos
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
⊢ 0 < ↑q ↔ 0 < q
state_after: no goals
tactic: norm_cast
Theorem: MeasureTheory.eLpNorm_eq_lintegral_rpow_nnnorm
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
f : α → F
⊢ eLpNorm f p μ = (∫⁻ (x : α), ↑‖f x‖₊ ^ p.toReal ∂μ) ^ (1 / p.toReal)
state_after: no goals
tactic: rw [eLpNorm_eq_eLpNorm' hp_ne_zero hp_ne_top, eLpNorm']
Theorem: LocalizedModule.liftOn_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
α : Type u_2
f : M × ↥S → α
wd : ∀ (p p' : M × ↥S), p ≈ p' → f p = f p'
m : M
s : ↥S
⊢ (mk m s).liftOn f wd = f (m, s)
state_after: no goals
tactic: convert Quotient.liftOn_mk f wd ⟨m, s⟩
Theorem: map_mul_eq_one
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : FunLike F M N
inst✝ : MonoidHomClass F M N
f : F
a b : M
h : a * b = 1
⊢ f a * f b = 1
state_after: no goals
tactic: rw [← map_mul, h, map_one]
Theorem: AkraBazziRecurrence.GrowsPolynomially.zpow
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

Proof steps:
state_before: f : ℝ → ℝ
p : ℤ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ p
state_after: f : ℝ → ℝ
p : ℤ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ ↑p
tactic: simp_rw [← rpow_intCast]
state_before: f : ℝ → ℝ
p : ℤ
hf : GrowsPolynomially f
hf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x
⊢ GrowsPolynomially fun x => f x ^ ↑p
state_after: no goals
tactic: exact hf.rpow p hf_nonneg
Theorem: Polynomial.mul_coeff_zero
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
⊢ (p * q).coeff 0 = p.coeff 0 * q.coeff 0
state_after: no goals
tactic: simp [coeff_mul]
Theorem: FractionalIdeal.coe_inv_of_nonzero
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
R₁ : Type u_4
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I J✝ J : FractionalIdeal R₁⁰ K
h : J ≠ 0
⊢ ↑J⁻¹ = IsLocalization.coeSubmodule K ⊤ / ↑J
state_after: no goals
tactic: simp_rw [inv_nonzero _ h, coe_one, coe_mk, IsLocalization.coeSubmodule_top]
Theorem: QuadraticMap.polar_comm
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
f : M → N
x y : M
⊢ polar f x y = polar f y x
state_after: no goals
tactic: rw [polar, polar, add_comm, sub_sub, sub_sub, add_comm (f x) (f y)]
Theorem: Multiset.toDFinsupp_inter
File: Mathlib/Data/DFinsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
⊢ toDFinsupp (s ∩ t) = toDFinsupp s ⊓ toDFinsupp t
state_after: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
i : α
⊢ (toDFinsupp (s ∩ t)) i = (toDFinsupp s ⊓ toDFinsupp t) i
tactic: ext i
state_before: case h
α : Type u_1
β : α → Type u_2
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
i : α
⊢ (toDFinsupp (s ∩ t)) i = (toDFinsupp s ⊓ toDFinsupp t) i
state_after: no goals
tactic: simp [inf_eq_min]
Theorem: Finset.cast_card_erase_of_mem
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ ↑(s.erase a).card = ↑s.card - 1
state_after: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ 1 ≤ s.card
tactic: rw [card_erase_of_mem hs, Nat.cast_sub, Nat.cast_one]
state_before: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ 1 ≤ s.card
state_after: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ s.Nonempty
tactic: rw [Nat.add_one_le_iff, Finset.card_pos]
state_before: α : Type u_1
β : Type u_2
R✝ : Type u_3
s✝ t : Finset α
a b : α
inst✝¹ : DecidableEq α
R : Type u_4
inst✝ : AddGroupWithOne R
s : Finset α
hs : a ∈ s
⊢ s.Nonempty
state_after: no goals
tactic: exact ⟨a, hs⟩
Theorem: Turing.Tape.move_left_mk'
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
L R : ListBlank Γ
⊢ move Dir.left (mk' L R) = mk' L.tail (ListBlank.cons L.head R)
state_after: no goals
tactic: simp only [Tape.move, Tape.mk', ListBlank.head_cons, eq_self_iff_true, ListBlank.cons_head_tail,
    and_self_iff, ListBlank.tail_cons]
Theorem: PadicInt.denseRange_intCast
File: Mathlib/NumberTheory/Padics/RingHoms.lean

Proof steps:
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ DenseRange Int.cast
state_after: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ closure (Set.range Int.cast)
tactic: intro x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ closure (Set.range Int.cast)
state_after: case refine_1
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ IsClosed {b | b ∈ closure (Set.range Int.cast)}

case refine_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ∀ (a : ℕ), ↑a ∈ closure (Set.range Int.cast)
tactic: refine DenseRange.induction_on denseRange_natCast x ?_ ?_
Theorem: MeasureTheory.ae_eq_trim_of_stronglyMeasurable
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
H : Type u_6
β : Type u_7
γ : Type u_8
inst✝² : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝¹ : TopologicalSpace γ
inst✝ : MetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f =ᶠ[ae μ] g
⊢ f =ᶠ[ae (μ.trim hm)] g
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
H : Type u_6
β : Type u_7
γ : Type u_8
inst✝² : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝¹ : TopologicalSpace γ
inst✝ : MetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}
tactic: rwa [EventuallyEq, ae_iff, trim_measurableSet_eq hm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
H : Type u_6
β : Type u_7
γ : Type u_8
inst✝² : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝¹ : TopologicalSpace γ
inst✝ : MetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}
state_after: no goals
tactic: exact (hf.measurableSet_eq_fun hg).compl
Theorem: prime_pow_iff
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
n : ℕ
⊢ Prime (p ^ n) ↔ Prime p ∧ n = 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
n : ℕ
hp : Prime (p ^ n)
⊢ Prime p ∧ n = 1
tactic: refine ⟨fun hp ↦ ?_, fun ⟨hp, hn⟩ ↦ by simpa [hn]⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
n : ℕ
hp : Prime (p ^ n)
⊢ Prime p ∧ n = 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
n : ℕ
hp : Prime (p ^ n)
⊢ n = 1
tactic: suffices n = 1 by aesop
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
n : ℕ
hp : Prime (p ^ n)
⊢ n = 1
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime (p ^ 0)
⊢ 0 = 1

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
n : ℕ
hp : Prime (p ^ (n + 1))
⊢ n + 1 = 1
tactic: cases' n with n
Theorem: PresheafOfModules.pushforward_obj_map_apply
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Pushforward.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
R : Dᵒᵖ ⥤ RingCat
S : Cᵒᵖ ⥤ RingCat
φ : S ⟶ F.op ⋙ R
M : PresheafOfModules R
X Y : Cᵒᵖ
f : X ⟶ Y
m : ↑((ModuleCat.restrictScalars (φ.app X)).obj (M.obj (Opposite.op (F.obj (Opposite.unop X)))))
⊢ (((pushforward φ).obj M).map f) m = (M.map (F.map f.unop).op) m
state_after: no goals
tactic: rfl
Theorem: Int.ModEq.sub
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : c ≡ d [ZMOD n]
⊢ a - c ≡ b - d [ZMOD n]
state_after: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : c ≡ d [ZMOD n]
⊢ a + -c ≡ b + -d [ZMOD n]
tactic: rw [sub_eq_add_neg, sub_eq_add_neg]
state_before: m n a b c d : ℤ
h₁ : a ≡ b [ZMOD n]
h₂ : c ≡ d [ZMOD n]
⊢ a + -c ≡ b + -d [ZMOD n]
state_after: no goals
tactic: exact h₁.add h₂.neg
Theorem: AddAction.stabilizer_finset_singleton
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
⊢ stabilizer G {b} = stabilizer G b
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
state_after: no goals
tactic: simp
Theorem: ZNum.bit1_of_bit1
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : PosNum
⊢ sub' 1 (a + a) = (neg a).bit1
state_after: α : Type u_1
a : PosNum
⊢ a.bit0.pred'.toZNumNeg = (neg a).bit1
tactic: rw [PosNum.one_sub', a.bit0_of_bit0]
state_before: α : Type u_1
a : PosNum
⊢ a.bit0.pred'.toZNumNeg = (neg a).bit1
state_after: no goals
tactic: rfl
Theorem: LiouvilleWith.add_nat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (x + ↑n) ↔ LiouvilleWith p x
state_after: no goals
tactic: rw [← Rat.cast_natCast n, add_rat_iff]