ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: _private.Mathlib.RingTheory.PowerSeries.Order.0.PowerSeries.order_add_of_order_eq.aux
File: Mathlib/RingTheory/PowerSeries/Order.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ (φ + ψ).order ≤ φ.order ⊓ ψ.order
state_after: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ (φ + ψ).order = φ.order
tactic: suffices order (φ + ψ) = order φ by
    rw [le_inf_iff, this]
    exact ⟨le_rfl, le_of_lt H⟩
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ (φ + ψ).order = φ.order
state_after: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ (∀ (i : ℕ), ↑i = φ.order → (coeff R i) (φ + ψ) ≠ 0) ∧ ∀ (i : ℕ), ↑i < φ.order → (coeff R i) (φ + ψ) = 0
tactic: rw [order_eq]
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ (∀ (i : ℕ), ↑i = φ.order → (coeff R i) (φ + ψ) ≠ 0) ∧ ∀ (i : ℕ), ↑i < φ.order → (coeff R i) (φ + ψ) = 0
state_after: case left
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ ∀ (i : ℕ), ↑i = φ.order → (coeff R i) (φ + ψ) ≠ 0

case right
R : Type u_1
inst✝ : Semiring R
φ✝ φ ψ : R⟦X⟧
_h : φ.order ≠ ψ.order
H : φ.order < ψ.order
⊢ ∀ (i : ℕ), ↑i < φ.order → (coeff R i) (φ + ψ) = 0
tactic: constructor
Theorem: AddAction.fixedBy_eq_univ_iff_eq_zero
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝⁵ : Group G
inst✝⁴ : MulAction G α
M : Type u_3
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : FaithfulSMul G α
inst✝ : FaithfulSMul M α
m : M
⊢ fixedBy α m = Set.univ ↔ m = 1
state_after: α : Type u_1
G : Type u_2
inst✝⁵ : Group G
inst✝⁴ : MulAction G α
M : Type u_3
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : FaithfulSMul G α
inst✝ : FaithfulSMul M α
m : M
⊢ (∀ (x : α), x ∈ fixedBy α m) ↔ (fun x => m • x) = fun x => 1 • x
tactic: rw [← (smul_left_injective' (M := M) (α := α)).eq_iff, Set.eq_univ_iff_forall]
state_before: α : Type u_1
G : Type u_2
inst✝⁵ : Group G
inst✝⁴ : MulAction G α
M : Type u_3
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : FaithfulSMul G α
inst✝ : FaithfulSMul M α
m : M
⊢ (∀ (x : α), x ∈ fixedBy α m) ↔ (fun x => m • x) = fun x => 1 • x
state_after: no goals
tactic: simp_rw [Function.funext_iff, one_smul, mem_fixedBy]
Theorem: Stream'.WSeq.toList'_cons
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : List α
s : WSeq α
a : α
⊢ (Computation.corec
        (fun x =>
          match x with
          | (l, s) =>
            match Seq.destruct s with
            | none => Sum.inl l.reverse
            | some (none, s') => Sum.inr (l, s')
            | some (some a, s') => Sum.inr (a :: l, s'))
        (l, cons a s)).destruct =
    Sum.inr
      (Computation.corec
        (fun x =>
          match x with
          | (l, s) =>
            match Seq.destruct s with
            | none => Sum.inl l.reverse
            | some (none, s') => Sum.inr (l, s')
            | some (some a, s') => Sum.inr (a :: l, s'))
        (a :: l, s))
state_after: no goals
tactic: simp [toList, cons]
Theorem: MeasureTheory.extend_eq_top
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

Proof steps:
state_before: α : Type u_1
P : α → Prop
m : (s : α) → P s → ℝ≥0∞
s : α
h : ¬P s
⊢ extend m s = ⊤
state_after: no goals
tactic: simp [extend, h]
Theorem: FirstOrder.Language.Substructure.FG.cg
File: Mathlib/ModelTheory/FinitelyGenerated.lean

Proof steps:
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
h : N.FG
⊢ N.CG
state_after: case intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
s : Set M
hf : s.Finite
h : ((closure L).toFun s).FG
⊢ ((closure L).toFun s).CG
tactic: obtain ⟨s, hf, rfl⟩ := fg_def.1 h
state_before: case intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
s : Set M
hf : s.Finite
h : ((closure L).toFun s).FG
⊢ ((closure L).toFun s).CG
state_after: no goals
tactic: exact ⟨s, hf.countable, rfl⟩
Theorem: Fin.insertNth_last
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
⊢ (last n).insertNth x p = snoc (fun j => _root_.cast ⋯ (p j)) x
state_after: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
⊢ p = (last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x)
tactic: refine insertNth_eq_iff.2 ⟨by simp, ?_⟩
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
⊢ p = (last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x)
state_after: case h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
j : Fin n
⊢ p j = (last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x) j
tactic: ext j
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
j : Fin n
⊢ p j = (last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x) j
state_after: case h.h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
j : Fin n
⊢ HEq (p j) ((last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x) j)
tactic: apply eq_of_heq
state_before: case h.h
m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
j : Fin n
⊢ HEq (p j) ((last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x) j)
state_after: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
j : Fin n
⊢ HEq (p j) (snoc (fun j => _root_.cast ⋯ (p j)) x j.castSucc)

m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
x : α (last n)
p : (j : Fin n) → α ((last n).succAbove j)
j : Fin n
⊢ HEq (snoc (fun j => _root_.cast ⋯ (p j)) x j.castSucc) ((last n).removeNth (snoc (fun j => _root_.cast ⋯ (p j)) x) j)
tactic: trans snoc (fun j ↦ _root_.cast (congr_arg α (succAbove_last_apply j)) (p j)) x (castSucc j)
Theorem: CstarRing.norm_one
File: Mathlib/Analysis/CstarAlgebra/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
α : Type u_3
inst✝³ : NormedRing E
inst✝² : StarRing E
inst✝¹ : CstarRing E
inst✝ : Nontrivial E
⊢ ‖1‖ = 1
state_after: 𝕜 : Type u_1
E : Type u_2
α : Type u_3
inst✝³ : NormedRing E
inst✝² : StarRing E
inst✝¹ : CstarRing E
inst✝ : Nontrivial E
this : 0 < ‖1‖
⊢ ‖1‖ = 1
tactic: have : 0 < ‖(1 : E)‖ := norm_pos_iff.mpr one_ne_zero
state_before: 𝕜 : Type u_1
E : Type u_2
α : Type u_3
inst✝³ : NormedRing E
inst✝² : StarRing E
inst✝¹ : CstarRing E
inst✝ : Nontrivial E
this : 0 < ‖1‖
⊢ ‖1‖ = 1
state_after: no goals
tactic: rw [← mul_left_inj' this.ne', ← norm_star_mul_self, mul_one, star_one, one_mul]
Theorem: Set.measure_eq_iInf_isOpen
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
⊢ μ A = ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U
state_after: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
⊢ ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U ≤ μ A
tactic: refine le_antisymm (le_iInf₂ fun s hs => le_iInf fun _ => μ.mono hs) ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
⊢ ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U ≤ μ A
state_after: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
r : ℝ≥0∞
hr : μ A < r
⊢ ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U < r
tactic: refine le_of_forall_lt' fun r hr => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
r : ℝ≥0∞
hr : μ A < r
⊢ ⨅ U, ⨅ (_ : A ⊆ U), ⨅ (_ : IsOpen U), μ U < r
state_after: no goals
tactic: simpa only [iInf_lt_iff, exists_prop] using A.exists_isOpen_lt_of_lt r hr
Theorem: HomogeneousIdeal.toIdeal_iInf₂
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_5
κ' : κ → Sort u_6
s : (i : κ) → κ' i → HomogeneousIdeal 𝒜
⊢ (⨅ i, ⨅ j, s i j).toIdeal = ⨅ i, ⨅ j, (s i j).toIdeal
state_after: no goals
tactic: simp_rw [toIdeal_iInf]
Theorem: Finset.addEnergy_eq_sum_sq'
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ Eₘ[s, t] =
    ∑ a ∈ s * t,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ∑ x ∈ s * t, (filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)).card
tactic: simp_rw [mulEnergy_eq_card_filter, sq, ← card_product]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ∑ x ∈ s * t, (filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)).card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ((s * t).disjiUnion
        (fun x => filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t))
        ?h).card

case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (↑(s * t)).PairwiseDisjoint fun x =>
    filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)
tactic: rw [← card_disjiUnion]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ((s * t).disjiUnion
        (fun x => filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t))
        ?h).card

case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (↑(s * t)).PairwiseDisjoint fun x =>
    filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)
state_after: case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (↑(s * t)).PairwiseDisjoint fun x =>
    filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t)

α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ s t : Finset α
⊢ (filter (fun x => x.1.1 * x.1.2 = x.2.1 * x.2.2) ((s ×ˢ t) ×ˢ s ×ˢ t)).card =
    ((s * t).disjiUnion
        (fun x => filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t) ×ˢ filter (fun x_1 => x_1.1 * x_1.2 = x) (s ×ˢ t))
        ?h).card
tactic: swap
Theorem: Matrix.StdBasisMatrix.trace_eq
File: Mathlib/Data/Matrix/Basis.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
⊢ (stdBasisMatrix i i c).trace = c
state_after: no goals
tactic: simp [trace, -diag_apply]
Theorem: Finset.ruzsa_triangle_inequality_sub_add_add
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B.card ≤ (A * B).card * (B * C).card
state_after: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B⁻¹.card ≤ (A / B⁻¹).card * (B⁻¹ / C).card
tactic: rw [← div_inv_eq_mul, ← card_inv B, ← card_inv (B * C), mul_inv, ← div_eq_mul_inv]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ (A / C).card * B⁻¹.card ≤ (A / B⁻¹).card * (B⁻¹ / C).card
state_after: no goals
tactic: exact ruzsa_triangle_inequality_div_div_div _ _ _
Theorem: Real.exp_zero
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ rexp 0 = 1
state_after: no goals
tactic: simp [Real.exp]
Theorem: MeasureTheory.L2.eLpNorm_rpow_two_norm_lt_top
File: Mathlib/MeasureTheory/Function/L2Space.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : ↥(Lp F 2 μ)
⊢ eLpNorm (fun x => ‖↑↑f x‖ ^ 2) 1 μ < ⊤
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : ↥(Lp F 2 μ)
h_two : ENNReal.ofReal 2 = 2
⊢ eLpNorm (fun x => ‖↑↑f x‖ ^ 2) 1 μ < ⊤
tactic: have h_two : ENNReal.ofReal (2 : ℝ) = 2 := by simp [zero_le_one]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : ↥(Lp F 2 μ)
h_two : ENNReal.ofReal 2 = 2
⊢ eLpNorm (fun x => ‖↑↑f x‖ ^ 2) 1 μ < ⊤
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : ↥(Lp F 2 μ)
h_two : ENNReal.ofReal 2 = 2
⊢ eLpNorm (↑↑f) 2 μ ^ 2 < ⊤
tactic: rw [eLpNorm_norm_rpow f zero_lt_two, one_mul, h_two]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f : ↥(Lp F 2 μ)
h_two : ENNReal.ofReal 2 = 2
⊢ eLpNorm (↑↑f) 2 μ ^ 2 < ⊤
state_after: no goals
tactic: exact ENNReal.rpow_lt_top_of_nonneg zero_le_two (Lp.eLpNorm_ne_top f)
Theorem: Turing.ToPartrec.Code.nil_eval
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: v : List ℕ
⊢ nil.eval v = pure []
state_after: no goals
tactic: simp [nil]
Theorem: HomologicalComplex₂.total.mapAux.mapMap_D₁
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_5, u_1} C
inst✝⁴ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝³ : DecidableEq I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
inst✝¹ : K.HasTotal c₁₂
inst✝ : L.HasTotal c₁₂
i₁₂ i₁₂' : I₁₂
⊢ GradedObject.mapMap (toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂ ≫ L.D₁ c₁₂ i₁₂ i₁₂' =
    K.D₁ c₁₂ i₁₂ i₁₂' ≫ GradedObject.mapMap (toGradedObjectMap φ) (c₁.π c₂ c₁₂) i₁₂'
state_after: no goals
tactic: aesop_cat
Theorem: ArithmeticFunction.isMultiplicative_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : MonoidWithZero R
⊢ 1 1 = 1
state_after: no goals
tactic: simp
state_before: R : Type u_1
inst✝ : MonoidWithZero R
⊢ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → m.Coprime n → 1 (m * n) = 1 m * 1 n
state_after: R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
⊢ 1 (m * n) = 1 m * 1 n
tactic: intro m n hm _hn hmn
state_before: R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
⊢ 1 (m * n) = 1 m * 1 n
state_after: case inl
R : Type u_1
inst✝ : MonoidWithZero R
n : ℕ
_hn : n ≠ 0
hm : 1 ≠ 0
hmn : Coprime 1 n
⊢ 1 (1 * n) = 1 1 * 1 n

case inr
R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
hm' : m ≠ 1
⊢ 1 (m * n) = 1 m * 1 n
tactic: rcases eq_or_ne m 1 with (rfl | hm')
state_before: case inr
R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
hm' : m ≠ 1
⊢ 1 (m * n) = 1 m * 1 n
state_after: case inr
R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
hm' : m ≠ 1
⊢ m * n ≠ 1
tactic: rw [one_apply_ne, one_apply_ne hm', zero_mul]
state_before: case inr
R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
hm' : m ≠ 1
⊢ m * n ≠ 1
state_after: case inr
R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
hm' : m ≠ 1
⊢ ¬m = 1 ∨ ¬n = 1
tactic: rw [Ne, mul_eq_one, not_and_or]
state_before: case inr
R : Type u_1
inst✝ : MonoidWithZero R
m n : ℕ
hm : m ≠ 0
_hn : n ≠ 0
hmn : m.Coprime n
hm' : m ≠ 1
⊢ ¬m = 1 ∨ ¬n = 1
state_after: no goals
tactic: exact Or.inl hm'
Theorem: Part.mem_chain_of_mem_ωSup
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ Part.ωSup c
⊢ some a ∈ c
state_after: α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ if h : ∃ a, some a ∈ c then some (Classical.choose h) else none
⊢ some a ∈ c
tactic: simp only [Part.ωSup] at h
state_before: α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ if h : ∃ a, some a ∈ c then some (Classical.choose h) else none
⊢ some a ∈ c
state_after: case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (Classical.choose h_1)
⊢ some a ∈ c

case neg
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ¬∃ a, some a ∈ c
h : a ∈ none
⊢ some a ∈ c
tactic: split_ifs at h with h_1
Theorem: Ordinal.toPGame_lt_iff
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
⊢ a.toPGame < b.toPGame → a < b
state_after: a b : Ordinal.{u_1}
⊢ ¬a < b → ¬a.toPGame < b.toPGame
tactic: contrapose
state_before: a b : Ordinal.{u_1}
⊢ ¬a < b → ¬a.toPGame < b.toPGame
state_after: a b : Ordinal.{u_1}
⊢ b ≤ a → ¬a.toPGame < b.toPGame
tactic: rw [not_lt]
state_before: a b : Ordinal.{u_1}
⊢ b ≤ a → ¬a.toPGame < b.toPGame
state_after: no goals
tactic: exact fun h => not_lt_of_le (toPGame_le h)
Theorem: LocallyConstant.indicator_apply
File: Mathlib/Topology/LocallyConstant/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
R : Type u_5
inst✝ : One R
U : Set X
f : LocallyConstant X R
hU : IsClopen U
s : Set R
⊢ IsOpen (U.mulIndicator ⇑f ⁻¹' s)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
R : Type u_5
inst✝ : One R
U : Set X
f : LocallyConstant X R
hU : IsClopen U
s : Set R
⊢ IsOpen (⇑f ⁻¹' s ∩ U ∪ 1 ⁻¹' s ∩ Uᶜ)
tactic: rw [mulIndicator_preimage, Set.ite, Set.diff_eq]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝¹ : TopologicalSpace X
R : Type u_5
inst✝ : One R
U : Set X
f : LocallyConstant X R
hU : IsClopen U
s : Set R
⊢ IsOpen (⇑f ⁻¹' s ∩ U ∪ 1 ⁻¹' s ∩ Uᶜ)
state_after: no goals
tactic: exact ((f.2 s).inter hU.isOpen).union ((IsLocallyConstant.const 1 s).inter hU.compl.isOpen)
Theorem: Matrix.mul_mul_apply
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalSemiring α
inst✝ : Fintype n
A B C : Matrix n n α
i j : n
⊢ (A * B * C) i j = A i ⬝ᵥ B *ᵥ Cᵀ j
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalSemiring α
inst✝ : Fintype n
A B C : Matrix n n α
i j : n
⊢ (A * (B * C)) i j = A i ⬝ᵥ B *ᵥ Cᵀ j
tactic: rw [Matrix.mul_assoc]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalSemiring α
inst✝ : Fintype n
A B C : Matrix n n α
i j : n
⊢ (A * (B * C)) i j = A i ⬝ᵥ B *ᵥ Cᵀ j
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalSemiring α
inst✝ : Fintype n
A B C : Matrix n n α
i j : n
⊢ ∑ x : n, A i x * ∑ j_1 : n, B x j_1 * C j_1 j = ∑ x : n, A i x * ∑ x_1 : n, B x x_1 * Cᵀ j x_1
tactic: simp only [mul_apply, dotProduct, mulVec]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalSemiring α
inst✝ : Fintype n
A B C : Matrix n n α
i j : n
⊢ ∑ x : n, A i x * ∑ j_1 : n, B x j_1 * C j_1 j = ∑ x : n, A i x * ∑ x_1 : n, B x x_1 * Cᵀ j x_1
state_after: no goals
tactic: rfl
Theorem: span_coeff_minpolyDiv
File: Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean

Proof steps:
state_before: R : Type u_2
K : Type ?u.87778
L : Type ?u.87781
S : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : Algebra K L
x : S
hx : IsIntegral R x
⊢ Submodule.span R (Set.range (minpolyDiv R x).coeff) = Subalgebra.toSubmodule (Algebra.adjoin R {x})
state_after: R : Type u_2
K : Type ?u.87778
L : Type ?u.87781
S : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : Algebra K L
x : S
hx : IsIntegral R x
a✝ : Nontrivial S
⊢ Submodule.span R (Set.range (minpolyDiv R x).coeff) = Subalgebra.toSubmodule (Algebra.adjoin R {x})
tactic: nontriviality S
Theorem: Nat.binaryRec_eq'
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ : ℕ
C : ℕ → Sort u_1
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
b : Bool
n : ℕ
h : f false 0 z = z ∨ (n = 0 → b = true)
⊢ binaryRec z f (bit b n) = f b n (binaryRec z f n)
state_after: m n✝ : ℕ
C : ℕ → Sort u_1
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
b : Bool
n : ℕ
h : f false 0 z = z ∨ (n = 0 → b = true)
⊢ (if n0 : bit b n = 0 then ⋯.mpr z
    else
      let n' := (bit b n).div2;
      let_fun _x := ⋯;
      ⋯.mpr (f (bit b n).bodd n' (binaryRec z f n'))) =
    f b n (binaryRec z f n)
tactic: rw [binaryRec]
state_before: m n✝ : ℕ
C : ℕ → Sort u_1
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
b : Bool
n : ℕ
h : f false 0 z = z ∨ (n = 0 → b = true)
⊢ (if n0 : bit b n = 0 then ⋯.mpr z
    else
      let n' := (bit b n).div2;
      let_fun _x := ⋯;
      ⋯.mpr (f (bit b n).bodd n' (binaryRec z f n'))) =
    f b n (binaryRec z f n)
state_after: case pos
m n✝ : ℕ
C : ℕ → Sort u_1
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
b : Bool
n : ℕ
h : f false 0 z = z ∨ (n = 0 → b = true)
h' : bit b n = 0
⊢ ⋯.mpr z = f b n (binaryRec z f n)

case neg
m n✝ : ℕ
C : ℕ → Sort u_1
z : C 0
f : (b : Bool) → (n : ℕ) → C n → C (bit b n)
b : Bool
n : ℕ
h : f false 0 z = z ∨ (n = 0 → b = true)
h' : ¬bit b n = 0
⊢ (let n' := (bit b n).div2;
    let_fun _x := ⋯;
    ⋯.mpr (f (bit b n).bodd n' (binaryRec z f n'))) =
    f b n (binaryRec z f n)
tactic: split_ifs with h'