ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Orientation.two_zsmul_oangle_smul_smul_self
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
r₁ r₂ : ℝ
⊢ 2 • o.oangle (r₁ • x) (r₂ • x) = 0
state_after: no goals
tactic: by_cases h : r₁ = 0 <;> simp [h]
Theorem: SimpleGraph.cliqueSet_zero
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s✝ : Finset α
G : SimpleGraph α
s : Finset α
⊢ s ∈ G.cliqueSet 0 ↔ s ∈ {∅}
state_after: no goals
tactic: simp
Theorem: List.getElem_inits
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l : List α
n : ℕ
h : n < l.inits.length
⊢ l.inits[n] = take n l
state_after: no goals
tactic: induction l generalizing n with
  | nil => simp
  | cons a l ihl =>
    cases n with
    | zero => simp
    | succ n => simp [ihl]
Theorem: WeakDual.CharacterSpace.ext_ker
File: Mathlib/Topology/Algebra/Module/CharacterSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
⊢ φ = ψ
state_after: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
⊢ φ x = ψ x
tactic: ext x
state_before: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
⊢ φ x = ψ x
state_after: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
this : x - (algebraMap 𝕜 A) (ψ x) ∈ RingHom.ker φ
⊢ φ x = ψ x
tactic: have : x - algebraMap 𝕜 A (ψ x) ∈ RingHom.ker φ := by
    simpa only [h, RingHom.mem_ker, map_sub, AlgHomClass.commutes] using sub_self (ψ x)
state_before: case h
𝕜 : Type u_1
A : Type u_2
inst✝⁷ : CommRing 𝕜
inst✝⁶ : NoZeroDivisors 𝕜
inst✝⁵ : TopologicalSpace 𝕜
inst✝⁴ : ContinuousAdd 𝕜
inst✝³ : ContinuousConstSMul 𝕜 𝕜
inst✝² : TopologicalSpace A
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
φ ψ : ↑(characterSpace 𝕜 A)
h : RingHom.ker φ = RingHom.ker ψ
x : A
this : x - (algebraMap 𝕜 A) (ψ x) ∈ RingHom.ker φ
⊢ φ x = ψ x
state_after: no goals
tactic: rwa [RingHom.mem_ker, map_sub, AlgHomClass.commutes, sub_eq_zero] at this
Theorem: CategoryTheory.Pi.optionEquivalence_inverse
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝¹ : (i : I) → Category.{v₁, u₁} (C i)
C' : Option J → Type u₁
inst✝ : (i : Option J) → Category.{v₁, u₁} (C' i)
⊢ (Functor.pi' fun i =>
        match i with
        | none => Prod.fst (C' none) ((j : J) → C' (some j))
        | some i => Prod.snd (C' none) ((j : J) → C' (some j)) ⋙ eval (fun j => C' (some j)) i) ⋙
      (eval C' none).prod' (Functor.pi' fun i => eval C' (some i)) ≅
    𝟭 (C' none × ((j : J) → C' (some j)))
state_after: no goals
tactic: exact Iso.refl _
Theorem: CategoryTheory.isZero_Tor'_succ_of_projective
File: Mathlib/CategoryTheory/Monoidal/Tor.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : MonoidalCategory C
inst✝³ : Abelian C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasProjectiveResolutions C
X Y : C
inst✝ : Projective X
n : ℕ
⊢ IsZero (((Tor' C (n + 1)).obj X).obj Y)
state_after: no goals
tactic: apply Functor.isZero_leftDerived_obj_projective_succ
Theorem: Nat.not_dvd_of_pos_of_lt
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h1 : 0 < n
h2 : n < m
⊢ ¬m ∣ n
state_after: case intro
a b c d m k✝ : ℕ
p q : ℕ → Prop
k : ℕ
h1 : 0 < m * k
h2 : m * k < m
⊢ False
tactic: rintro ⟨k, rfl⟩
state_before: case intro
a b c d m k✝ : ℕ
p q : ℕ → Prop
k : ℕ
h1 : 0 < m * k
h2 : m * k < m
⊢ False
state_after: case intro.inl
a b c d m k : ℕ
p q : ℕ → Prop
h1 : 0 < m * 0
h2 : m * 0 < m
⊢ False

case intro.inr
a b c d m k✝ : ℕ
p q : ℕ → Prop
k : ℕ
h1 : 0 < m * k
h2 : m * k < m
hk : k > 0
⊢ False
tactic: rcases Nat.eq_zero_or_pos k with (rfl | hk)
Theorem: CategoryTheory.ShortComplex.FunctorEquivalence.counitIso_hom_app_app_τ₂
File: Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝¹ : J ⥤ ShortComplex C
x✝ : J
⊢ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₁).hom ≫ (((𝟭 (J ⥤ ShortComplex C)).obj x✝¹).obj x✝).f =
    (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).f ≫ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₂).hom
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝¹ : J ⥤ ShortComplex C
x✝ : J
⊢ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₂).hom ≫ (((𝟭 (J ⥤ ShortComplex C)).obj x✝¹).obj x✝).g =
    (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).g ≫ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₃).hom
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝ : J ⥤ ShortComplex C
⊢ ∀ {X Y : J} (f : X ⟶ Y),
    ((inverse J C ⋙ functor J C).obj x✝).map f ≫
        ((fun x =>
              isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₁)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₂)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₃) ⋯ ⋯)
            Y).hom =
      ((fun x =>
              isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₁)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₂)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₃) ⋯ ⋯)
            X).hom ≫
        ((𝟭 (J ⥤ ShortComplex C)).obj x✝).map f
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
⊢ ∀ {X Y : J ⥤ ShortComplex C} (f : X ⟶ Y),
    (inverse J C ⋙ functor J C).map f ≫
        ((fun x =>
              NatIso.ofComponents
                (fun x_1 =>
                  isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₁)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₂)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₃) ⋯ ⋯)
                ⋯)
            Y).hom =
      ((fun x =>
              NatIso.ofComponents
                (fun x_1 =>
                  isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₁)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₂)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₃) ⋯ ⋯)
                ⋯)
            X).hom ≫
        (𝟭 (J ⥤ ShortComplex C)).map f
state_after: no goals
tactic: aesop_cat
Theorem: _private.Mathlib.NumberTheory.LegendreSymbol.AddCharacter.0.AddChar.ringChar_ne
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Finite F
inst✝ : DecidableEq F
⊢ ringChar ℂ ≠ ringChar F
state_after: no goals
tactic: simpa only [ringChar.eq_zero] using (CharP.ringChar_ne_zero_of_finite F).symm
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ (equalizerSubobjectIso f g).hom ≫ equalizer.ι f g = (equalizerSubobject f g).arrow
state_after: no goals
tactic: simp [equalizerSubobjectIso]
Theorem: Real.rpow_le_one
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1
state_after: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1 ^ z
tactic: rw [← one_rpow z]
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx1 : 0 ≤ x
hx2 : x ≤ 1
hz : 0 ≤ z
⊢ x ^ z ≤ 1 ^ z
state_after: no goals
tactic: exact rpow_le_rpow hx1 hx2 hz
Theorem: Set.infsep_of_fintype
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable s.Nontrivial
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : s.Nontrivial
⊢ s.offDiag.toFinset.Nonempty
state_after: no goals
tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable s.Nontrivial
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
⊢ s.infsep = if hs : s.Nontrivial then s.offDiag.toFinset.inf' ⋯ (uncurry dist) else 0
state_after: case pos
α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable s.Nontrivial
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : s.Nontrivial
⊢ s.infsep = s.offDiag.toFinset.inf' ⋯ (uncurry dist)

case neg
α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
x y z : α
s t : Set α
inst✝² : Decidable s.Nontrivial
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
hs : ¬s.Nontrivial
⊢ s.infsep = 0
tactic: split_ifs with hs
Theorem: LieModule.independent_weightSpaceOf
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
x : L
⊢ CompleteLattice.Independent fun χ => weightSpaceOf M χ x
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
x : L
⊢ CompleteLattice.Independent fun i => ↑(weightSpaceOf M i x)
tactic: rw [LieSubmodule.independent_iff_coe_toSubmodule]
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
x : L
⊢ CompleteLattice.Independent fun i => ↑(weightSpaceOf M i x)
state_after: no goals
tactic: exact (toEnd R L M x).independent_genEigenspace
Theorem: MeasureTheory.Integrable.condKernel_ae
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
E : Type u_3
F : Type u_4
mα : MeasurableSpace α
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
f : α × Ω → F
hf_int : Integrable f ρ
⊢ ∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)
state_after: α : Type u_1
Ω : Type u_2
E : Type u_3
F : Type u_4
mα : MeasurableSpace α
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
f : α × Ω → F
hf_int : Integrable f ρ
hf_ae : AEStronglyMeasurable f ρ
⊢ ∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)
tactic: have hf_ae : AEStronglyMeasurable f ρ := hf_int.1
state_before: α : Type u_1
Ω : Type u_2
E : Type u_3
F : Type u_4
mα : MeasurableSpace α
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
f : α × Ω → F
hf_int : Integrable f ρ
hf_ae : AEStronglyMeasurable f ρ
⊢ ∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)
state_after: α : Type u_1
Ω : Type u_2
E : Type u_3
F : Type u_4
mα : MeasurableSpace α
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
f : α × Ω → F
hf_int :
  (∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)) ∧
    Integrable (fun a => ∫ (ω : Ω), ‖f (a, ω)‖ ∂ρ.condKernel a) ρ.fst
hf_ae : AEStronglyMeasurable f ρ
⊢ ∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)
tactic: rw [← hf_ae.ae_integrable_condKernel_iff] at hf_int
state_before: α : Type u_1
Ω : Type u_2
E : Type u_3
F : Type u_4
mα : MeasurableSpace α
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
ρ : Measure (α × Ω)
inst✝ : IsFiniteMeasure ρ
f : α × Ω → F
hf_int :
  (∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)) ∧
    Integrable (fun a => ∫ (ω : Ω), ‖f (a, ω)‖ ∂ρ.condKernel a) ρ.fst
hf_ae : AEStronglyMeasurable f ρ
⊢ ∀ᵐ (a : α) ∂ρ.fst, Integrable (fun ω => f (a, ω)) (ρ.condKernel a)
state_after: no goals
tactic: exact hf_int.1
Theorem: Complex.betaIntegral_eval_one_right
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

Proof steps:
state_before: u : ℂ
hu : 0 < u.re
⊢ u.betaIntegral 1 = 1 / u
state_after: u : ℂ
hu : 0 < u.re
⊢ ∫ (x : ℝ) in 0 ..1, ↑x ^ (u - 1) = 1 / u
tactic: simp_rw [betaIntegral, sub_self, cpow_zero, mul_one]
state_before: u : ℂ
hu : 0 < u.re
⊢ ∫ (x : ℝ) in 0 ..1, ↑x ^ (u - 1) = 1 / u
state_after: u : ℂ
hu : 0 < u.re
⊢ (↑1 ^ (u - 1 + 1) - ↑0 ^ (u - 1 + 1)) / (u - 1 + 1) = 1 / u

u : ℂ
hu : 0 < u.re
⊢ -1 < (u - 1).re
tactic: rw [integral_cpow (Or.inl _)]
Theorem: AddMonoidAlgebra.mul_single_zero_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddZeroClass G
f : k[G]
r : k
x a : G
⊢ a + 0 = x ↔ a = x
state_after: no goals
tactic: rw [add_zero]
Theorem: Ideal.eq_jacobson_iff_not_mem
File: Mathlib/RingTheory/JacobsonIdeal.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
⊢ I.jacobson = I ↔ ∀ x ∉ I, ∃ M, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M
state_after: case mp
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
⊢ I.jacobson = I → ∀ x ∉ I, ∃ M, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M

case mpr
R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I : Ideal R
⊢ (∀ x ∉ I, ∃ M, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M) → I.jacobson = I
tactic: constructor
Theorem: WittVector.zero_coeff
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ (aeval (Function.uncurry fun i => (![] i).coeff)) (wittZero p n) = 0
state_after: no goals
tactic: simp only [wittZero_eq_zero, map_zero]
Theorem: IsSquare.div
File: Mathlib/Algebra/Group/Even.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionCommMonoid α
a b : α
ha : IsSquare a
hb : IsSquare b
⊢ IsSquare (a / b)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionCommMonoid α
a b : α
ha : IsSquare a
hb : IsSquare b
⊢ IsSquare (a * b⁻¹)
tactic: rw [div_eq_mul_inv]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionCommMonoid α
a b : α
ha : IsSquare a
hb : IsSquare b
⊢ IsSquare (a * b⁻¹)
state_after: no goals
tactic: exact ha.mul hb.inv
Theorem: LinearMap.toMatrix₂'_compl₂
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R✝ : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
R : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
f : (m' → R) →ₗ[R] m → R
⊢ (toMatrix₂' R) (B.compl₂ f) = (toMatrix₂' R) B * toMatrix' f
state_after: R✝ : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
R : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
f : (m' → R) →ₗ[R] m → R
⊢ (toMatrix₂' R) (B.compl₁₂ id f) = (toMatrix₂' R) (B ∘ₗ id) * toMatrix' f
tactic: rw [← LinearMap.comp_id B, ← LinearMap.compl₁₂]
state_before: R✝ : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
R : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
f : (m' → R) →ₗ[R] m → R
⊢ (toMatrix₂' R) (B.compl₁₂ id f) = (toMatrix₂' R) (B ∘ₗ id) * toMatrix' f
state_after: no goals
tactic: simp
Theorem: Real.arctan_inv_of_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x : ℝ
h : 0 < x
⊢ arctan x⁻¹ = π / 2 - arctan x
state_after: case hx₁
x : ℝ
h : 0 < x
⊢ -(π / 2) < π / 2 - arctan x

case hx₂
x : ℝ
h : 0 < x
⊢ π / 2 - arctan x < π / 2
tactic: rw [← arctan_tan (x := _ - _), tan_pi_div_two_sub, tan_arctan]
Theorem: CategoryTheory.ShortComplex.leftHomology_ext
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝ : S.HasLeftHomology
A : C
f₁ f₂ : S.leftHomology ⟶ A
h : S.leftHomologyπ ≫ f₁ = S.leftHomologyπ ≫ f₂
⊢ f₁ = f₂
state_after: no goals
tactic: simpa only [leftHomology_ext_iff] using h
Theorem: HahnSeries.SummableFamily.hsum_sub
File: Mathlib/RingTheory/HahnSeries/Summable.lean

Proof steps:
state_before: Γ : Type u_1
R✝ : Type u_2
inst✝² : OrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R✝
α : Type u_3
R : Type u_4
inst✝ : Ring R
s t : SummableFamily Γ R α
⊢ (s - t).hsum = s.hsum - t.hsum
state_after: no goals
tactic: rw [← lsum_apply, LinearMap.map_sub, lsum_apply, lsum_apply]
Theorem: Set.piecewise_insert_self
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ (insert j s).piecewise f g j = f j
state_after: no goals
tactic: simp [piecewise]
Theorem: WithBot.preimage_coe_Ioo
File: Mathlib/Order/Interval/Set/WithBotTop.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some ⁻¹' Ioo ↑a ↑b = Ioo a b
state_after: no goals
tactic: simp [← Ioi_inter_Iio]
Theorem: divp_eq_divp_iff
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : CommMonoid α
x y : α
ux uy : αˣ
⊢ x /ₚ ux = y /ₚ uy ↔ x * ↑uy = y * ↑ux
state_after: no goals
tactic: rw [divp_eq_iff_mul_eq, divp_mul_eq_mul_divp, divp_eq_iff_mul_eq]
Theorem: HurwitzZeta.completedHurwitzZetaEven_one_sub
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedHurwitzZetaEven a (1 - s) = completedCosZeta a s
state_after: no goals
tactic: rw [completedHurwitzZetaEven, completedCosZeta, sub_div,
    (by norm_num : (1 / 2 : ℂ) = ↑(1 / 2 : ℝ)),
    (by rfl : (1 / 2 : ℝ) = (hurwitzEvenFEPair a).k),
    (hurwitzEvenFEPair a).functional_equation (s / 2),
    (by rfl : (hurwitzEvenFEPair a).ε = 1),
    one_smul]
Theorem: Submonoid.LocalizationMap.mul_inv
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : M →* N
h : ∀ (y : ↥S), IsUnit (f ↑y)
x₁ x₂ : M
y₁ y₂ : ↥S
⊢ f x₁ * ↑((IsUnit.liftRight (f.restrict S) h) y₁)⁻¹ = f x₂ * ↑((IsUnit.liftRight (f.restrict S) h) y₂)⁻¹ ↔
    f (x₁ * ↑y₂) = f (x₂ * ↑y₁)
state_after: no goals
tactic: rw [mul_inv_right h, mul_assoc, mul_comm _ (f y₂), ← mul_assoc, mul_inv_left h, mul_comm x₂,
    f.map_mul, f.map_mul]
Theorem: map_comp_zsmul
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✝³ : FunLike F G H
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
g : ι → G
n : ℤ
⊢ ⇑f ∘ (g ^ n) = ⇑f ∘ g ^ n
state_after: no goals
tactic: simp
Theorem: List.nthLe_cons_length
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
x : α
xs : List α
n : ℕ
h : n = xs.length
⊢ n < (x :: xs).length
state_after: no goals
tactic: simp [h]