ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: exists_pos_right_iff_sameRay
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R x y
state_after: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R y x
tactic: rw [SameRay.sameRay_comm]
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ x = r • y) ↔ SameRay R y x
state_after: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • y = x) ↔ SameRay R y x
tactic: simp_rw [eq_comm (a := x)]
state_before: R : Type u_1
inst✝² : LinearOrderedField R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
x y : M
hx : x ≠ 0
hy : y ≠ 0
⊢ (∃ r, 0 < r ∧ r • y = x) ↔ SameRay R y x
state_after: no goals
tactic: exact exists_pos_left_iff_sameRay hy hx
Theorem: Complex.continuous_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ Continuous sin
state_after: ⊢ Continuous fun z => (cexp (-z * I) - cexp (z * I)) * I / 2
tactic: change Continuous fun z => (exp (-z * I) - exp (z * I)) * I / 2
state_before: ⊢ Continuous fun z => (cexp (-z * I) - cexp (z * I)) * I / 2
state_after: no goals
tactic: continuity
Theorem: MulChar.ext_iff
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ χ' : MulChar R R'
⊢ χ = χ' → ∀ (a : Rˣ), χ ↑a = χ' ↑a
state_after: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a : Rˣ
⊢ χ ↑a = χ ↑a
tactic: rintro rfl a
state_before: R : Type u_1
inst✝¹ : CommMonoid R
R' : Type u_2
inst✝ : CommMonoidWithZero R'
χ : MulChar R R'
a : Rˣ
⊢ χ ↑a = χ ↑a
state_after: no goals
tactic: rfl
Theorem: List.getElem_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
i : ℕ
h : i < (ofFn f).length
⊢ i < n
state_after: no goals
tactic: simp_all
state_before: α : Type u
n : ℕ
f : Fin n → α
i : ℕ
h : i < (ofFn f).length
⊢ (ofFn f)[i] = f ⟨i, ⋯⟩
state_after: no goals
tactic: simp [ofFn, getElem_ofFn_go]
Theorem: ProbabilityTheory.Kernel.integral_withDensity
File: Mathlib/Probability/Kernel/WithDensity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f : β → E
inst✝ : IsSFiniteKernel κ
a : α
g : α → β → ℝ≥0
hg : Measurable (Function.uncurry g)
⊢ ∫ (b : β), f b ∂(κ.withDensity fun a b => ↑(g a b)) a = ∫ (b : β), g a b • f b ∂κ a
state_after: case f_meas
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f : β → E
inst✝ : IsSFiniteKernel κ
a : α
g : α → β → ℝ≥0
hg : Measurable (Function.uncurry g)
⊢ Measurable (g a)

case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
E : Type u_4
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f : β → E
inst✝ : IsSFiniteKernel κ
a : α
g : α → β → ℝ≥0
hg : Measurable (Function.uncurry g)
⊢ Measurable (Function.uncurry fun a b => ↑(g a b))
tactic: rw [Kernel.withDensity_apply, integral_withDensity_eq_integral_smul]
Theorem: OrderEmbedding.birkhoffSet_inf
File: Mathlib/Order/Birkhoff.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a b : α
⊢ birkhoffSet (a ⊓ b) = birkhoffSet a ∩ birkhoffSet b
state_after: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a b : α
⊢ (if h : IsEmpty α then ofIsEmpty
      else
        let_fun this := Fintype.toOrderBot α;
        RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
          { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
      (a ⊓ b) =
    (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        a ∩
      (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        b
tactic: unfold OrderEmbedding.birkhoffSet
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a b : α
⊢ (if h : IsEmpty α then ofIsEmpty
      else
        let_fun this := Fintype.toOrderBot α;
        RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
          { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
      (a ⊓ b) =
    (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        a ∩
      (if h : IsEmpty α then ofIsEmpty
        else
          let_fun this := Fintype.toOrderBot α;
          RelEmbedding.trans OrderIso.lowerSetSupIrred.toOrderEmbedding
            { toFun := SetLike.coe, inj' := ⋯, map_rel_iff' := ⋯ })
        b
state_after: no goals
tactic: split <;> simp [eq_iff_true_of_subsingleton]
Theorem: NormedAddGroupHom.comp_zero
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : NormedAddGroupHom V₂ V₃
⊢ f.comp 0 = 0
state_after: case H
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ (f.comp 0) x✝ = 0 x✝
tactic: ext
state_before: case H
V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g : NormedAddGroupHom V₁ V₂
f : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ (f.comp 0) x✝ = 0 x✝
state_after: no goals
tactic: exact map_zero f
Theorem: Cardinal.derivBFamily_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : c.IsRegular
hι : o.card < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c.ord, f i hi b < c.ord
a : Ordinal.{u}
⊢ lift.{u, u} o.card < c
state_after: no goals
tactic: rwa [lift_id]
Theorem: mem_rightAddCoset_iff
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Set α
x a : α
x✝ : x ∈ op a • s
b : α
hb : b ∈ s
Eq : (fun x => op a • x) b = x
⊢ x * a⁻¹ ∈ s
state_after: no goals
tactic: simp [Eq.symm, hb]
state_before: α : Type u_1
inst✝ : Group α
s : Set α
x a : α
h : x * a⁻¹ ∈ s
⊢ (fun x => op a • x) (x * a⁻¹) = x
state_after: no goals
tactic: simp
Theorem: Topology.IsScott.scottContinuous_iff_continuous
File: Mathlib/Topology/Order/ScottTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : TopologicalSpace α
inst✝³ : IsScott α
s : Set α
a : α
inst✝² : Preorder β
inst✝¹ : TopologicalSpace β
inst✝ : IsScott β
f : α → β
⊢ ScottContinuous f ↔ Continuous f
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : TopologicalSpace α
inst✝³ : IsScott α
s : Set α
a : α
inst✝² : Preorder β
inst✝¹ : TopologicalSpace β
inst✝ : IsScott β
f : α → β
h : ScottContinuous f
u : Set β
hu : IsOpen u
⊢ IsOpen (f ⁻¹' u)

case refine_2
α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : TopologicalSpace α
inst✝³ : IsScott α
s : Set α
a : α
inst✝² : Preorder β
inst✝¹ : TopologicalSpace β
inst✝ : IsScott β
f : α → β
⊢ Continuous f → ScottContinuous f
tactic: refine ⟨fun h ↦ continuous_def.2 fun u hu ↦ ?_, ?_⟩
Theorem: SimpleGraph.Walk.map_map
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
⊢ Walk.map f' (Walk.map f p) = Walk.map (f'.comp f) p
state_after: no goals
tactic: induction p with
  | nil => rfl
  | cons _ _ ih => simp [ih]
Theorem: SetTheory.PGame.neg_ofLists
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
L R : List PGame
⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)
state_after: xl xr : Type u
L R : List PGame
⊢ (HEq (fun j => -R[↑j.down]) fun i => -R[↑i.down]) ∧ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]
tactic: simp only [ofLists, neg_def, List.getElem_map, mk.injEq, List.length_map, true_and]
state_before: xl xr : Type u
L R : List PGame
⊢ (HEq (fun j => -R[↑j.down]) fun i => -R[↑i.down]) ∧ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]
state_after: case left
xl xr : Type u
L R : List PGame
⊢ HEq (fun j => -R[↑j.down]) fun i => -R[↑i.down]

case right
xl xr : Type u
L R : List PGame
⊢ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]
tactic: constructor
Theorem: Nat.Ico_succ_left
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
⊢ Ico a.succ b = Ioo a b
state_after: case a
a b c x : ℕ
⊢ x ∈ Ico a.succ b ↔ x ∈ Ioo a b
tactic: ext x
state_before: case a
a b c x : ℕ
⊢ x ∈ Ico a.succ b ↔ x ∈ Ioo a b
state_after: no goals
tactic: rw [mem_Ico, mem_Ioo, succ_le_iff]
Theorem: Complex.log_eq_integral
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: z : ℂ
hz : 1 + z ∈ slitPlane
⊢ log (1 + z) = z * ∫ (t : ℝ) in 0 ..1, (1 + t • z)⁻¹
state_after: case h.e'_2
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ log (1 + z) = log (1 + z) - log 1
tactic: convert (integral_unitInterval_deriv_eq_sub (continuousOn_one_add_mul_inv hz)
    (fun _ ht ↦ hasDerivAt_log <|
      StarConvex.add_smul_mem starConvex_one_slitPlane hz ht.1 ht.2)).symm using 1
state_before: case h.e'_2
z : ℂ
hz : 1 + z ∈ slitPlane
⊢ log (1 + z) = log (1 + z) - log 1
state_after: no goals
tactic: simp only [log_one, sub_zero]
Theorem: ZMod.val_neg_of_ne_zero
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
nz : NeZero n
a : ZMod n
na : NeZero a
⊢ (-a).val = n - a.val
state_after: no goals
tactic: simp_all [neg_val a, na.out]
Theorem: RingHom.finite_stableUnderComposition
File: Mathlib/RingTheory/RingHom/Finite.lean

Proof steps:
state_before: ⊢ StableUnderComposition @Finite
state_after: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : f.Finite
hg : g.Finite
⊢ (g.comp f).Finite
tactic: introv R hf hg
state_before: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : f.Finite
hg : g.Finite
⊢ (g.comp f).Finite
state_after: no goals
tactic: exact hg.comp hf
Theorem: InitialSeg.leLT_apply
File: Mathlib/Order/InitialSeg.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
⊢ (f.leLT g).toRelEmbedding a = g.toRelEmbedding (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
⊢ (match f.ltOrEq with
        | Sum.inl f' => f'.trans g
        | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    g.toRelEmbedding (f a)
tactic: delta InitialSeg.leLT
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
⊢ (match f.ltOrEq with
        | Sum.inl f' => f'.trans g
        | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    g.toRelEmbedding (f a)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
f' : r ≺i s
⊢ (match Sum.inl f' with
        | Sum.inl f' => f'.trans g
        | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    g.toRelEmbedding (f a)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝¹ : IsWellOrder β s
inst✝ : IsTrans γ t
f : r ≼i s
g : s ≺i t
a : α
f' : r ≃r s
⊢ (match Sum.inr f' with
        | Sum.inl f' => f'.trans g
        | Sum.inr f' => PrincipalSeg.equivLT f' g).toRelEmbedding
      a =
    g.toRelEmbedding (f a)
tactic: cases' f.ltOrEq with f' f'
Theorem: SimpleGraph.Subgraph.induce_mono
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ G'.induce s ≤ G''.induce s'
state_after: case left
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ (G'.induce s).verts ⊆ (G''.induce s').verts

case right
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
hg : G' ≤ G''
hs : s ⊆ s'
⊢ ∀ ⦃v w : V⦄, (G'.induce s).Adj v w → (G''.induce s').Adj v w
tactic: constructor
Theorem: toIcoDiv_eq_floor
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ toIcoDiv hp a b = ⌊(b - a) / p⌋
state_after: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - ⌊(b - a) / p⌋ • p ∈ Set.Ico a (a + p)
tactic: refine toIcoDiv_eq_of_sub_zsmul_mem_Ico hp ?_
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - ⌊(b - a) / p⌋ • p ∈ Set.Ico a (a + p)
state_after: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ 0 ≤ b - a - ↑⌊(b - a) / p⌋ * p ∧ b - a - ↑⌊(b - a) / p⌋ * p < p
tactic: rw [Set.mem_Ico, zsmul_eq_mul, ← sub_nonneg, add_comm, sub_right_comm, ← sub_lt_iff_lt_add,
    sub_right_comm _ _ a]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ 0 ≤ b - a - ↑⌊(b - a) / p⌋ * p ∧ b - a - ↑⌊(b - a) / p⌋ * p < p
state_after: no goals
tactic: exact ⟨Int.sub_floor_div_mul_nonneg _ hp, Int.sub_floor_div_mul_lt _ hp⟩
Theorem: innerDualCone_insert
File: Mathlib/Analysis/Convex/Cone/InnerDual.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s✝ t : Set H
x : H
s : Set H
⊢ (insert x s).innerDualCone = {x}.innerDualCone ⊓ s.innerDualCone
state_after: no goals
tactic: rw [insert_eq, innerDualCone_union]
Theorem: OreLocalization.smul_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
x : OreLocalization S R
⊢ x • 0 = 0
state_after: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r : R
s : ↥S
⊢ (r /ₒ s) • 0 = 0
tactic: induction' x with r s
state_before: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddMonoid X
inst✝ : DistribMulAction R X
r : R
s : ↥S
⊢ (r /ₒ s) • 0 = 0
state_after: no goals
tactic: rw [OreLocalization.zero_def, smul_div_one, smul_zero, zero_oreDiv, zero_oreDiv]
Theorem: ONote.repr_opow
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr
state_after: case mk
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
a : ONote
m : ℕ
e₁ : o₁.split = (a, m)
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr
tactic: cases' e₁ : split o₁ with a m
state_before: case mk
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
a : ONote
m : ℕ
e₁ : o₁.split = (a, m)
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr
state_after: case mk.intro
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
a : ONote
m : ℕ
e₁ : o₁.split = (a, m)
N₁ : a.NF
r₁ : o₁.repr = a.repr + ↑m
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr
tactic: cases' nf_repr_split e₁ with N₁ r₁
state_before: case mk.intro
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
a : ONote
m : ℕ
e₁ : o₁.split = (a, m)
N₁ : a.NF
r₁ : o₁.repr = a.repr + ↑m
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr
state_after: case mk.intro.zero
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
m : ℕ
e₁ : o₁.split = (zero, m)
N₁ : zero.NF
r₁ : o₁.repr = zero.repr + ↑m
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr

case mk.intro.oadd
o₁ o₂ : ONote
inst✝¹ : o₁.NF
inst✝ : o₂.NF
m : ℕ
a0 : ONote
n : ℕ+
a' : ONote
e₁ : o₁.split = (a0.oadd n a', m)
N₁ : (a0.oadd n a').NF
r₁ : o₁.repr = (a0.oadd n a').repr + ↑m
⊢ (o₁ ^ o₂).repr = o₁.repr ^ o₂.repr
tactic: cases' a with a0 n a'
Theorem: Finset.sum_equiv
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g✝ : α✝ → β
inst✝¹ : CommMonoid β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝ : CommMonoid α
s : Finset ι
t : Finset κ
f : ι → α
g : κ → α
e : ι ≃ κ
hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t
hfg : ∀ i ∈ s, f i = g (e i)
⊢ ∏ i ∈ s, f i = ∏ i ∈ t, g i
state_after: no goals
tactic: refine prod_nbij' e e.symm ?_ ?_ ?_ ?_ hfg <;> simp [hst]
Theorem: CategoryTheory.IsPushout.of_is_bilimit'
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPushout b.fst b.snd 0 0
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPushout (b.inl ≫ b.fst) 0 0 (0 ≫ 0)
tactic: refine IsPushout.of_left ?_ (by simp) (IsPushout.inl_snd' h)
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
Z X Y P : C
f : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPushout (b.inl ≫ b.fst) 0 0 (0 ≫ 0)
state_after: no goals
tactic: simp
Theorem: QuotientGroup.sound
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
⊢ g • ⇑(mk' N) ⁻¹' U = ⇑(mk' N) ⁻¹' U
state_after: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
x : G
⊢ x ∈ g • ⇑(mk' N) ⁻¹' U ↔ x ∈ ⇑(mk' N) ⁻¹' U
tactic: ext x
state_before: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
x : G
⊢ x ∈ g • ⇑(mk' N) ⁻¹' U ↔ x ∈ ⇑(mk' N) ⁻¹' U
state_after: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
x : G
⊢ (mk' N) (g⁻¹ • x) ∈ U ↔ (mk' N) x ∈ U
tactic: simp only [Set.mem_preimage, Set.mem_smul_set_iff_inv_smul_mem]
state_before: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
x : G
⊢ (mk' N) (g⁻¹ • x) ∈ U ↔ (mk' N) x ∈ U
state_after: case h.a.h.e'_4
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
x : G
⊢ (mk' N) (g⁻¹ • x) = (mk' N) x
tactic: congr! 1
state_before: case h.a.h.e'_4
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
U : Set (G ⧸ N)
g : ↥N.op
x : G
⊢ (mk' N) (g⁻¹ • x) = (mk' N) x
state_after: no goals
tactic: exact Quotient.sound ⟨g⁻¹, rfl⟩
Theorem: spectrum.one_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
⊢ σ 1 = σ (↑ₐ 1)
state_after: no goals
tactic: rw [Algebra.algebraMap_eq_smul_one, one_smul]
Theorem: differentiableAt_dslope_of_ne
File: Mathlib/Analysis/Calculus/Dslope.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
⊢ DifferentiableAt 𝕜 (dslope f a) b ↔ DifferentiableAt 𝕜 f b
state_after: no goals
tactic: simp only [← differentiableWithinAt_univ, differentiableWithinAt_dslope_of_ne h]
Theorem: add_pow_char_pow_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Semiring R
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n
state_after: R : Type u_1
inst✝¹ : Semiring R
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n + ↑p * r
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n
tactic: let ⟨r, hr⟩ := h.exists_add_pow_prime_pow_eq hp.out n
state_before: R : Type u_1
inst✝¹ : Semiring R
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n + ↑p * r
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n
state_after: no goals
tactic: simp [hr]
Theorem: Set.chainHeight_add_le_chainHeight_add
File: Mathlib/Order/Height.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
n m : ℕ
⊢ s.chainHeight + ↑n ≤ t.chainHeight + ↑m ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length + n ≤ l'.length + m
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
n m : ℕ
H : ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length + n ≤ l'.length + m
⊢ s.chainHeight + ↑n ≤ t.chainHeight + ↑m
tactic: refine
    ⟨fun e l h ↦
      le_chainHeight_add_nat_iff.1
        ((add_le_add_right (length_le_chainHeight_of_mem_subchain h) _).trans e),
      fun H ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
n m : ℕ
H : ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length + n ≤ l'.length + m
⊢ s.chainHeight + ↑n ≤ t.chainHeight + ↑m
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
n m : ℕ
H : ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length + n ≤ l'.length + m
h : s.chainHeight = ⊤
⊢ s.chainHeight + ↑n ≤ t.chainHeight + ↑m

case neg
α : Type u_1
β : Type u_2
inst✝¹ : LT α
inst✝ : LT β
s✝ t✝ : Set α
l : List α
a : α
s : Set α
t : Set β
n m : ℕ
H : ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length + n ≤ l'.length + m
h : ¬s.chainHeight = ⊤
⊢ s.chainHeight + ↑n ≤ t.chainHeight + ↑m
tactic: by_cases h : s.chainHeight = ⊤