ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WithBot.mul_eq_bot_iff
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithBot α
⊢ a * b = ⊥ ↔ a ≠ 0 ∧ b = ⊥ ∨ a = ⊥ ∧ b ≠ 0
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithBot α
⊢ (if a = 0 ∨ b = 0 then 0 else map₂ (fun x x_1 => x * x_1) a b) = ⊥ ↔ a ≠ 0 ∧ b = ⊥ ∨ a = ⊥ ∧ b ≠ 0
tactic: rw [mul_def]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithBot α
⊢ (if a = 0 ∨ b = 0 then 0 else map₂ (fun x x_1 => x * x_1) a b) = ⊥ ↔ a ≠ 0 ∧ b = ⊥ ∨ a = ⊥ ∧ b ≠ 0
state_after: no goals
tactic: aesop
Theorem: MeasureTheory.OuterMeasure.sInf_apply'
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
m : Set (OuterMeasure α)
s : Set α
h : s.Nonempty
hm : m = ∅
⊢ (sInf m) s = ⨅ t, ⨅ (_ : s ⊆ iUnion t), ∑' (n : ℕ), ⨅ μ ∈ m, μ (t n)
state_after: no goals
tactic: simp [hm, h]
Theorem: Int.isUnit_eq_one_or
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v : ℤ
hu : IsUnit u
⊢ u = 1 ∨ u = -1
state_after: no goals
tactic: simpa only [natAbs_of_isUnit hu] using natAbs_eq u
Theorem: WittVector.map_verschiebung
File: Mathlib/RingTheory/WittVector/Verschiebung.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
x : 𝕎 R
⊢ (map f) (verschiebung x) = verschiebung ((map f) x)
state_after: case h.zero
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
x : 𝕎 R
⊢ ((map f) (verschiebung x)).coeff 0 = (verschiebung ((map f) x)).coeff 0

case h.succ
p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
x : 𝕎 R
n✝ : ℕ
⊢ ((map f) (verschiebung x)).coeff (n✝ + 1) = (verschiebung ((map f) x)).coeff (n✝ + 1)
tactic: ext ⟨-, -⟩
Theorem: AlgebraicGeometry.IsOpenImmersion.app_eq_invApp_app_of_comp_eq_aux
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H✝ : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
fg : Y ⟶ X
H : fg = f ≫ g
h : IsOpenImmersion g
V : U.Opens
⊢ f ⁻¹ᵁ V = fg ⁻¹ᵁ g ''ᵁ V
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ f ⁻¹ᵁ V = (f ≫ g) ⁻¹ᵁ g ''ᵁ V
tactic: subst H
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ f ⁻¹ᵁ V = (f ≫ g) ⁻¹ᵁ g ''ᵁ V
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ f ⁻¹ᵁ V = (Opens.map f.val.base).obj ((Opens.map g.val.base).obj (g ''ᵁ V))
tactic: rw [Scheme.comp_val_base, Opens.map_comp_obj]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ f ⁻¹ᵁ V = (Opens.map f.val.base).obj ((Opens.map g.val.base).obj (g ''ᵁ V))
state_after: case e_a
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ V = (Opens.map g.val.base).obj (g ''ᵁ V)
tactic: congr 1
state_before: case e_a
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ V = (Opens.map g.val.base).obj (g ''ᵁ V)
state_after: case e_a.h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ ↑V = ↑((Opens.map g.val.base).obj (g ''ᵁ V))
tactic: ext1
state_before: case e_a.h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g✝ : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y U : Scheme
f : Y ⟶ U
g : U ⟶ X
h : IsOpenImmersion g
V : U.Opens
⊢ ↑V = ↑((Opens.map g.val.base).obj (g ''ᵁ V))
state_after: no goals
tactic: exact (Set.preimage_image_eq _ h.base_open.inj).symm
Theorem: ae_eq_trim_of_measurable
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝¹ : Type u_1
G : Type u_2
α✝ : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α✝
f✝ g✝ : α✝ → G
μ✝ : Measure α✝
α : Type u_4
E : Type u_5
m m0 : MeasurableSpace α
μ : Measure α
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
hm : m ≤ m0
f g : α → E
hf : Measurable f
hg : Measurable g
hfg : f =ᶠ[ae μ] g
⊢ f =ᶠ[ae (μ.trim hm)] g
state_after: α✝¹ : Type u_1
G : Type u_2
α✝ : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α✝
f✝ g✝ : α✝ → G
μ✝ : Measure α✝
α : Type u_4
E : Type u_5
m m0 : MeasurableSpace α
μ : Measure α
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
hm : m ≤ m0
f g : α → E
hf : Measurable f
hg : Measurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}
tactic: rwa [Filter.EventuallyEq, ae_iff, trim_measurableSet_eq hm _]
state_before: α✝¹ : Type u_1
G : Type u_2
α✝ : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Div G
m✝ : MeasurableSpace α✝
f✝ g✝ : α✝ → G
μ✝ : Measure α✝
α : Type u_4
E : Type u_5
m m0 : MeasurableSpace α
μ : Measure α
inst✝³ : MeasurableSpace E
inst✝² : AddGroup E
inst✝¹ : MeasurableSingletonClass E
inst✝ : MeasurableSub₂ E
hm : m ≤ m0
f g : α → E
hf : Measurable f
hg : Measurable g
hfg : f =ᶠ[ae μ] g
⊢ MeasurableSet {a | ¬f a = g a}
state_after: no goals
tactic: exact @MeasurableSet.compl α _ m (@measurableSet_eq_fun α m E _ _ _ _ _ _ hf hg)
Theorem: Real.natCast_lt_toNNReal
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r : ℝ
n : ℕ
⊢ ↑n < r.toNNReal ↔ ↑n < r
state_after: no goals
tactic: simpa only [not_le] using toNNReal_le_natCast.not
Theorem: mem_own_rightAddCoset
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
this : 1 * a ∈ op a • ↑s
⊢ a ∈ op a • ↑s
state_after: no goals
tactic: simpa
Theorem: LinearMap.range_smul
File: Mathlib/Algebra/Module/Submodule/Range.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝⁵ : Semifield K
inst✝⁴ : Semifield K₂
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
a : K
h : a ≠ 0
⊢ range (a • f) = range f
state_after: no goals
tactic: simpa only [range_eq_map] using Submodule.map_smul f _ a h
Theorem: ChainComplex.fromSingle₀Equiv_symm_apply_f_zero
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : X ⟶ C.X 0
⊢ ((C.fromSingle₀Equiv X).symm f).f 0 = f
state_after: no goals
tactic: simp [fromSingle₀Equiv]
Theorem: dense_closure
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ Dense (closure s) ↔ Dense s
state_after: no goals
tactic: rw [Dense, Dense, closure_closure]
Theorem: MeasureTheory.SignedMeasure.null_of_totalVariation_zero
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.totalVariation i = 0
⊢ ↑s i = 0
state_after: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.toJordanDecomposition.posPart i = 0 ∧ s.toJordanDecomposition.negPart i = 0
⊢ ↑s i = 0
tactic: rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.toJordanDecomposition.posPart i = 0 ∧ s.toJordanDecomposition.negPart i = 0
⊢ ↑s i = 0
state_after: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.toJordanDecomposition.posPart i = 0 ∧ s.toJordanDecomposition.negPart i = 0
⊢ ((if MeasurableSet i then (s.toJordanDecomposition.posPart i).toReal else 0) -
      if MeasurableSet i then (s.toJordanDecomposition.negPart i).toReal else 0) =
    0
tactic: rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
    Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.toJordanDecomposition.posPart i = 0 ∧ s.toJordanDecomposition.negPart i = 0
⊢ ((if MeasurableSet i then (s.toJordanDecomposition.posPart i).toReal else 0) -
      if MeasurableSet i then (s.toJordanDecomposition.negPart i).toReal else 0) =
    0
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.toJordanDecomposition.posPart i = 0 ∧ s.toJordanDecomposition.negPart i = 0
hi : MeasurableSet i
⊢ ((if MeasurableSet i then (s.toJordanDecomposition.posPart i).toReal else 0) -
      if MeasurableSet i then (s.toJordanDecomposition.negPart i).toReal else 0) =
    0

case neg
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : s.toJordanDecomposition.posPart i = 0 ∧ s.toJordanDecomposition.negPart i = 0
hi : ¬MeasurableSet i
⊢ ((if MeasurableSet i then (s.toJordanDecomposition.posPart i).toReal else 0) -
      if MeasurableSet i then (s.toJordanDecomposition.negPart i).toReal else 0) =
    0
tactic: by_cases hi : MeasurableSet i
Theorem: EuclideanDomain.dvd_div_of_mul_dvd
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
⊢ b ∣ c / a
state_after: case inl
R : Type u
inst✝ : EuclideanDomain R
b c : R
h : 0 * b ∣ c
⊢ b ∣ c / 0

case inr
R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a
tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case inr
R : Type u
inst✝ : EuclideanDomain R
a b c : R
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a
state_after: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ b ∣ a * b * d / a
tactic: rcases h with ⟨d, rfl⟩
state_before: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ b ∣ a * b * d / a
state_after: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ a * b * d / a = b * d
tactic: refine ⟨d, ?_⟩
state_before: case inr.intro
R : Type u
inst✝ : EuclideanDomain R
a b : R
ha : a ≠ 0
d : R
⊢ a * b * d / a = b * d
state_after: no goals
tactic: rw [mul_assoc, mul_div_cancel_left₀ _ ha]
Theorem: HomotopyCategory.homologyShiftIso_hom_app
File: Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : CategoryWithHomology C
n a a' : ℤ
ha' : n + a = a'
K : CochainComplex C ℤ
⊢ ((homologyFunctor C (up ℤ) 0).shiftIso n a a' ha').hom.app ((quotient C (up ℤ)).obj K) =
    (homologyFunctor C (up ℤ) a).map (((quotient C (up ℤ)).commShiftIso n).inv.app K) ≫
      (homologyFunctorFactors C (up ℤ) a).hom.app ((shiftFunctor (HomologicalComplex C (up ℤ)) n).obj K) ≫
        ((HomologicalComplex.homologyFunctor C (up ℤ) 0).shiftIso n a a' ha').hom.app K ≫
          (homologyFunctorFactors C (up ℤ) a').inv.app K
state_after: no goals
tactic: apply Functor.ShiftSequence.induced_shiftIso_hom_app_obj
Theorem: MeasureTheory.Integrable.ae_eq_of_forall_setIntegral_eq
File: Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ = ∫ (x : α) in s, g x ∂μ
⊢ f =ᶠ[ae μ] g
state_after: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ = ∫ (x : α) in s, g x ∂μ
⊢ f - g =ᶠ[ae μ] 0
tactic: rw [← sub_ae_eq_zero]
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ = ∫ (x : α) in s, g x ∂μ
⊢ f - g =ᶠ[ae μ] 0
state_after: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ = ∫ (x : α) in s, g x ∂μ
hfg' : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, (f - g) x ∂μ = 0
⊢ f - g =ᶠ[ae μ] 0
tactic: have hfg' : ∀ s : Set α, MeasurableSet s → μ s < ∞ → (∫ x in s, (f - g) x ∂μ) = 0 := by
    intro s hs hμs
    rw [integral_sub' hf.integrableOn hg.integrableOn]
    exact sub_eq_zero.mpr (hfg s hs hμs)
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
p : ℝ≥0∞
f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, f x ∂μ = ∫ (x : α) in s, g x ∂μ
hfg' : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∫ (x : α) in s, (f - g) x ∂μ = 0
⊢ f - g =ᶠ[ae μ] 0
state_after: no goals
tactic: exact Integrable.ae_eq_zero_of_forall_setIntegral_eq_zero (hf.sub hg) hfg'
Theorem: vectorSpan_insert_eq_vectorSpan
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.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
p : P
ps : Set P
h : p ∈ affineSpan k ps
⊢ vectorSpan k (insert p ps) = vectorSpan k ps
state_after: no goals
tactic: simp_rw [← direction_affineSpan, affineSpan_insert_eq_affineSpan _ h]
Theorem: continuous_sSup_dom
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
T : Set (TopologicalSpace α)
t₂ : TopologicalSpace β
⊢ Continuous f ↔ ∀ t ∈ T, Continuous f
state_after: no goals
tactic: simp only [continuous_iff_le_induced, sSup_le_iff]
Theorem: npow_mul_assoc
File: Mathlib/Algebra/Group/NatPowAssoc.lean

Proof steps:
state_before: M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
k m n : ℕ
x : M
⊢ x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)
state_after: no goals
tactic: simp only [← npow_add, add_assoc]
Theorem: IsCyclotomicExtension.singleton_zero_of_bot_eq_top
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
⊢ IsCyclotomicExtension ∅ A B
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊤
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}
tactic: refine (iff_adjoin_eq_top _ A _).2
    ⟨fun s hs => by simp at hs, _root_.eq_top_iff.2 fun x hx => ?_⟩
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊤
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊥
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}
tactic: rw [← h] at hx
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : Algebra A B
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
h : ⊥ = ⊤
x : B
hx : x ∈ ⊥
⊢ x ∈ adjoin A {b | ∃ n ∈ ∅, b ^ ↑n = 1}
state_after: no goals
tactic: simpa using hx
Theorem: SimpleGraph.set_walk_length_toFinset_eq
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : G.LocallyFinite
n : ℕ
u v : V
⊢ {p | p.length = n}.toFinset = G.finsetWalkLength n u v
state_after: case a
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : G.LocallyFinite
n : ℕ
u v : V
p : G.Walk u v
⊢ p ∈ {p | p.length = n}.toFinset ↔ p ∈ G.finsetWalkLength n u v
tactic: ext p
state_before: case a
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝¹ : DecidableEq V
inst✝ : G.LocallyFinite
n : ℕ
u v : V
p : G.Walk u v
⊢ p ∈ {p | p.length = n}.toFinset ↔ p ∈ G.finsetWalkLength n u v
state_after: no goals
tactic: simp [← coe_finsetWalkLength_eq]
Theorem: Cubic.c_eq_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ φ P.c = φ P.a * (x * y + x * z + y * z)
state_after: no goals
tactic: injection eq_sum_three_roots ha h3
Theorem: Filter.subsingleton_iff_bot_or_pure
File: Mathlib/Order/Filter/Subsingleton.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : Filter α
⊢ l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a
state_after: case refine_1
α : Type u_1
β : Type u_2
l : Filter α
hl : l.Subsingleton
⊢ l = ⊥ ∨ ∃ a, l = pure a

case refine_2
α : Type u_1
β : Type u_2
l : Filter α
⊢ (l = ⊥ ∨ ∃ a, l = pure a) → l.Subsingleton
tactic: refine ⟨fun hl ↦ ?_, ?_⟩
Theorem: AddSubgroup.map_symm_eq_iff_map_eq
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup N
e : G ≃* N
⊢ map (↑e.symm) H = K ↔ map (↑e) K = H
state_after: case mp
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup N
e : G ≃* N
⊢ map (↑e) (map (↑e.symm) H) = H

case mpr
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H K : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
e : G ≃* N
⊢ map (↑e.symm) (map (↑e) K) = K
tactic: constructor <;> rintro rfl
Theorem: LinearMap.isSymmetric_iff_inner_map_self_real
File: Mathlib/Analysis/InnerProductSpace/Symmetric.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : InnerProductSpace 𝕜 F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 G
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace ℝ E'
V : Type u_6
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
⊢ T.IsSymmetric ↔ ∀ (v : V), (starRingEnd ℂ) ⟪T v, v⟫_ℂ = ⟪T v, v⟫_ℂ
state_after: case mp
𝕜 : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : InnerProductSpace 𝕜 F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 G
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace ℝ E'
V : Type u_6
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
⊢ T.IsSymmetric → ∀ (v : V), (starRingEnd ℂ) ⟪T v, v⟫_ℂ = ⟪T v, v⟫_ℂ

case mpr
𝕜 : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : InnerProductSpace 𝕜 F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 G
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace ℝ E'
V : Type u_6
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
⊢ (∀ (v : V), (starRingEnd ℂ) ⟪T v, v⟫_ℂ = ⟪T v, v⟫_ℂ) → T.IsSymmetric
tactic: constructor
Theorem: IsClosed.not_mem_iff_infDist_pos
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
h : IsClosed s
hs : s.Nonempty
⊢ x ∉ s ↔ 0 < infDist x s
state_after: no goals
tactic: simp [h.mem_iff_infDist_zero hs, infDist_nonneg.gt_iff_ne]
Theorem: AddSubmonoid.closure_singleton_le_iff_mem
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
m : M
p : Submonoid M
⊢ closure {m} ≤ p ↔ m ∈ p
state_after: no goals
tactic: rw [closure_le, singleton_subset_iff, SetLike.mem_coe]
Theorem: Option.map_injective
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β
Hf : Function.Injective f
a₁ a₂ : α
H : Option.map f (some a₁) = Option.map f (some a₂)
⊢ some a₁ = some a₂
state_after: no goals
tactic: rw [Hf (Option.some.inj H)]
Theorem: Field.finInsepDegree_self
File: Mathlib/FieldTheory/SeparableClosure.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
⊢ finInsepDegree F F = 1
state_after: no goals
tactic: rw [finInsepDegree_def', insepDegree_self, Cardinal.one_toNat]
Theorem: Equiv.Perm.decomposeOption_apply
File: Mathlib/GroupTheory/Perm/Option.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
σ : Perm (Option α)
⊢ (fun i => swap none i.1 * optionCongr i.2) ((fun σ => (σ none, removeNone σ)) σ) = σ
state_after: no goals
tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
x✝ : Option α × Perm α
x : Option α
σ : Perm α
⊢ (fun σ => (σ none, removeNone σ)) ((fun i => swap none i.1 * optionCongr i.2) (x, σ)) = (x, σ)
state_after: α : Type u_1
inst✝ : DecidableEq α
x✝ : Option α × Perm α
x : Option α
σ : Perm α
this : removeNone (swap none x * optionCongr σ) = σ
⊢ (fun σ => (σ none, removeNone σ)) ((fun i => swap none i.1 * optionCongr i.2) (x, σ)) = (x, σ)
tactic: have : removeNone (swap none x * σ.optionCongr) = σ :=
      Equiv.optionCongr_injective (by simp [← mul_assoc])
state_before: α : Type u_1
inst✝ : DecidableEq α
x✝ : Option α × Perm α
x : Option α
σ : Perm α
this : removeNone (swap none x * optionCongr σ) = σ
⊢ (fun σ => (σ none, removeNone σ)) ((fun i => swap none i.1 * optionCongr i.2) (x, σ)) = (x, σ)
state_after: no goals
tactic: simp [← Perm.eq_inv_iff_eq, this]