ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: sup_sub_inf_eq_abs_sub
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a ⊔ b) / (a ⊓ b) = mabs (b / a)
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a / b ⊔ b / a ⊔ 1 = mabs (b / a)
tactic: simp_rw [sup_div, div_inf, div_self', sup_comm, sup_sup_sup_comm, sup_idem]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a / b ⊔ b / a ⊔ 1 = mabs (b / a)
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ 1 ≤ mabs (b / a)
tactic: rw [← inv_div, sup_comm (b := _ / _), ← mabs, sup_eq_left]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ 1 ≤ mabs (b / a)
state_after: no goals
tactic: exact one_le_mabs _
Theorem: ZMod.exists_sq_eq_neg_one_iff
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ IsSquare (-1) ↔ p % 4 ≠ 3
state_after: no goals
tactic: rw [FiniteField.isSquare_neg_one_iff, card p]
Theorem: PartialEquiv.refl_restr_target
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
⊢ ((PartialEquiv.refl α).restr s).target = s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
⊢ univ ∩ id ⁻¹' s = s
tactic: change univ ∩ id ⁻¹' s = s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
⊢ univ ∩ id ⁻¹' s = s
state_after: no goals
tactic: simp
Theorem: Directed.disjoint_iSup_right
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
h : Directed (fun x x_1 => x ≤ x_1) f
⊢ Disjoint a (⨆ i, f i) ↔ ∀ (i : ι), Disjoint a (f i)
state_after: no goals
tactic: simp_rw [disjoint_iff, h.inf_iSup_eq, iSup_eq_bot]
Theorem: SimpleGraph.Iso.mapNeighborSet_symm_apply_coe
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
f : G ≃g G'
v : V
w : ↑(G'.neighborSet (f v))
⊢ f.symm ↑w ∈ G.neighborSet v
state_after: no goals
tactic: simpa [RelIso.symm_apply_apply] using f.symm.apply_mem_neighborSet_iff.mpr w.2
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
f : G ≃g G'
v : V
w : ↑(G.neighborSet v)
⊢ (fun w => ⟨f.symm ↑w, ⋯⟩) ((fun w => ⟨f ↑w, ⋯⟩) w) = w
state_after: no goals
tactic: simp
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v✝ : V
f : G ≃g G'
v : V
w : ↑(G'.neighborSet (f v))
⊢ (fun w => ⟨f ↑w, ⋯⟩) ((fun w => ⟨f.symm ↑w, ⋯⟩) w) = w
state_after: no goals
tactic: simp
Theorem: Units.val_ofNearby
File: Mathlib/Analysis/Normed/Ring/Units.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
y : R
h : ‖y - ↑x‖ < ‖↑x⁻¹‖⁻¹
⊢ y = ↑(x.add (y - ↑x) h)
state_after: no goals
tactic: simp
Theorem: MeasureTheory.le_addContent_diff
File: Mathlib/MeasureTheory/Measure/AddContent.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m s - m t ≤ m (s \ t)
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m (s ∩ t ∪ s \ t) - m t ≤ m (s \ t)
tactic: conv_lhs => rw [← inter_union_diff s t]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m (s ∩ t ∪ s \ t) - m t ≤ m (s \ t)
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m (s \ t) + m (s ∩ t) - m t ≤ m (s \ t)
tactic: rw [addContent_union hC (hC.inter_mem hs ht) (hC.diff_mem hs ht) disjoint_inf_sdiff, add_comm]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m (s \ t) + m (s ∩ t) - m t ≤ m (s \ t)
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m (s \ t) + (m (s ∩ t) - m t) = m (s \ t)
tactic: refine add_tsub_le_assoc.trans_eq ?_
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
m✝ m' m : AddContent C
hC : IsSetRing C
hs : s ∈ C
ht : t ∈ C
⊢ m (s \ t) + (m (s ∩ t) - m t) = m (s \ t)
state_after: no goals
tactic: rw [tsub_eq_zero_of_le
    (addContent_mono hC.isSetSemiring (hC.inter_mem hs ht) ht inter_subset_right), add_zero]
Theorem: Topology.IsLowerSet.monotone_iff_continuous
File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsLowerSet α
inst✝ : Topology.IsLowerSet β
f : α → β
⊢ Monotone f ↔ Continuous f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsLowerSet α
inst✝ : Topology.IsLowerSet β
f : α → β
⊢ Monotone (⇑toDual ∘ f ∘ ⇑ofDual) ↔ Continuous f
tactic: rw [← monotone_dual_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : Topology.IsLowerSet α
inst✝ : Topology.IsLowerSet β
f : α → β
⊢ Monotone (⇑toDual ∘ f ∘ ⇑ofDual) ↔ Continuous f
state_after: no goals
tactic: exact IsUpperSet.monotone_iff_continuous (α := αᵒᵈ) (β := βᵒᵈ)
    (f := (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ))
Theorem: CoxeterSystem.leftInvSeq_reverse
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ cs.leftInvSeq ω.reverse = (cs.rightInvSeq ω).reverse
state_after: no goals
tactic: simp [leftInvSeq_eq_reverse_rightInvSeq_reverse]
Theorem: sub_self
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n : ℤ
a : G
⊢ a / a = 1
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_right_inv a]
Theorem: addOrderOf_nsmul_of_dvd
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n✝ m : ℕ
x : G
n : ℕ
hn : n ≠ 0
dvd : n ∣ orderOf x
⊢ orderOf (x ^ n) = orderOf x / n
state_after: no goals
tactic: rw [orderOf_pow' _ hn, Nat.gcd_eq_right dvd]
Theorem: CochainComplex.HomComplex.Cochain.ofHoms_zero
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
⊢ (ofHoms fun p => 0) = 0
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.scaleRoots_eval₂_mul_of_commute
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
K : Type u_4
inst✝³ : Semiring S
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Field K
p : S[X]
f : S →+* A
a : A
s : S
hsa : Commute (f s) a
hf : ∀ (s₁ s₂ : S), Commute (f s₁) (f s₂)
⊢ eval₂ f (f s * a) (p.scaleRoots s) = f s ^ p.natDegree * eval₂ f a p
state_after: no goals
tactic: calc
    _ = (scaleRoots p s).support.sum fun i =>
          f (coeff p i * s ^ (p.natDegree - i)) * (f s * a) ^ i := by
      simp [eval₂_eq_sum, sum_def]
    _ = p.support.sum fun i => f (coeff p i * s ^ (p.natDegree - i)) * (f s * a) ^ i :=
      (Finset.sum_subset (support_scaleRoots_le p s) fun i _hi hi' => by
        let this : coeff p i * s ^ (p.natDegree - i) = 0 := by simpa using hi'
        simp [this])
    _ = p.support.sum fun i : ℕ => f (p.coeff i) * f s ^ (p.natDegree - i + i) * a ^ i :=
      (Finset.sum_congr rfl fun i _hi => by
        simp_rw [f.map_mul, f.map_pow, pow_add, hsa.mul_pow, mul_assoc])
    _ = p.support.sum fun i : ℕ => f s ^ p.natDegree * (f (p.coeff i) * a ^ i) :=
      Finset.sum_congr rfl fun i hi => by
        rw [mul_assoc, ← map_pow, (hf _ _).left_comm, map_pow, tsub_add_cancel_of_le]
        exact le_natDegree_of_ne_zero (Polynomial.mem_support_iff.mp hi)
    _ = f s ^ p.natDegree * eval₂ f a p := by simp [← Finset.mul_sum, eval₂_eq_sum, sum_def]
Theorem: MeasureTheory.hitting_bot_le_iff
File: Mathlib/Probability/Process/HittingTime.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
u : ι → Ω → β
s : Set β
f : Filtration ℕ m
i n : ι
ω : Ω
hx : ∃ j ≤ n, u j ω ∈ s
⊢ hitting u s ⊥ n ω ≤ i ↔ ∃ j ≤ i, u j ω ∈ s
state_after: case inl
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
u : ι → Ω → β
s : Set β
f : Filtration ℕ m
i n : ι
ω : Ω
hx : ∃ j ≤ n, u j ω ∈ s
hi : i < n
⊢ hitting u s ⊥ n ω ≤ i ↔ ∃ j ≤ i, u j ω ∈ s

case inr
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : ConditionallyCompleteLinearOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
u : ι → Ω → β
s : Set β
f : Filtration ℕ m
i n : ι
ω : Ω
hx : ∃ j ≤ n, u j ω ∈ s
hi : n ≤ i
⊢ hitting u s ⊥ n ω ≤ i ↔ ∃ j ≤ i, u j ω ∈ s
tactic: cases' lt_or_le i n with hi hi
Theorem: tprod_eq_mul_tprod_ite'
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommMonoid α
inst✝³ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
b : β
hf : Multipliable (update f b 1)
n : β
⊢ f n = (if n = b then f n else 1) * update f b 1 n
state_after: no goals
tactic: split_ifs with h <;> simp [update_apply, h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommMonoid α
inst✝³ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
b : β
hf : Multipliable (update f b 1)
⊢ (∏' (x : β), if x = b then f x else 1) * ∏' (x : β), update f b 1 x =
    (if b = b then f b else 1) * ∏' (x : β), update f b 1 x
state_after: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommMonoid α
inst✝³ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
b : β
hf : Multipliable (update f b 1)
⊢ (∏' (x : β), if x = b then f x else 1) = if b = b then f b else 1
tactic: congr
state_before: case e_a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommMonoid α
inst✝³ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
b : β
hf : Multipliable (update f b 1)
⊢ (∏' (x : β), if x = b then f x else 1) = if b = b then f b else 1
state_after: no goals
tactic: exact tprod_eq_mulSingle b fun b' hb' ↦ if_neg hb'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : CommMonoid α
inst✝³ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
b : β
hf : Multipliable (update f b 1)
⊢ (if b = b then f b else 1) * ∏' (x : β), update f b 1 x = f b * ∏' (x : β), if x = b then 1 else f x
state_after: no goals
tactic: simp only [update, eq_self_iff_true, if_true, eq_rec_constant, dite_eq_ite]
Theorem: Quiver.Path.obj_eq_of_cons_eq_cons
File: Mathlib/Combinatorics/Quiver/Path.lean

Proof steps:
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p : Path a b
p' : Path a c
e : b ⟶ d
e' : c ⟶ d
h : p.cons e = p'.cons e'
⊢ b = c
state_after: no goals
tactic: injection h
Theorem: RingHom.kerLift_injective
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : Semiring S
f : R →+* S
a : R
⊢ a ∈ ker f → f a = 0
state_after: no goals
tactic: simp only [mem_ker, imp_self]
Theorem: Finpartition.bot_isEquipartition
File: Mathlib/Order/Partition/Equipartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
⊢ ∀ a ∈ ↑⊥.parts, a.card = 1 ∨ a.card = 1 + 1
state_after: no goals
tactic: simp
Theorem: Action.leftUnitor_inv_hom
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ (λ_ X).inv.hom = (λ_ X.V).inv
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ 𝟙 X.V ≫ (λ_ X.V).inv ≫ (𝟙 (𝟙_ V) ⊗ 𝟙 X.V) = (λ_ X.V).inv
tactic: dsimp
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
X : Action V G
⊢ 𝟙 X.V ≫ (λ_ X.V).inv ≫ (𝟙 (𝟙_ V) ⊗ 𝟙 X.V) = (λ_ X.V).inv
state_after: no goals
tactic: simp
Theorem: LocalizedModule.subsingleton_iff
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
S : Submonoid R
⊢ Subsingleton (LocalizedModule S M) ↔ ∀ (m : M), ∃ r ∈ S, r • m = 0
state_after: no goals
tactic: simp_rw [subsingleton_iff_ker_eq_top, ← top_le_iff, SetLike.le_def,
    mem_ker_mkLinearMap_iff, Submodule.mem_top, true_implies]
Theorem: threeAPFree_insert_of_lt
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ ThreeGPFree (insert a s) ↔ ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ (ThreeGPFree s ∧
      (∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
        ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
tactic: refine threeGPFree_insert.trans ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ (ThreeGPFree s ∧
      (∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
        ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ ((ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
      ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
tactic: rw [← and_assoc]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ ((ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
      ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
state_after: no goals
tactic: exact and_iff_left fun b hb c hc h => ((mul_lt_mul_of_lt_of_lt (hs _ hb) (hs _ hc)).ne h).elim
Theorem: LocalRing.surjective_units_map_of_local_ringHom
File: Mathlib/RingTheory/LocalRing/RingHom/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
⊢ Function.Surjective ⇑(Units.map ↑f)
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
⊢ ∃ a_1, (Units.map ↑f) a_1 = a
tactic: intro a
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
⊢ ∃ a_1, (Units.map ↑f) a_1 = a
state_after: case intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
b : R
hb : f b = ↑a
⊢ ∃ a_1, (Units.map ↑f) a_1 = a
tactic: obtain ⟨b, hb⟩ := hf (a : S)
state_before: case intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
b : R
hb : f b = ↑a
⊢ ∃ a_1, (Units.map ↑f) a_1 = a
state_after: case h
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
b : R
hb : f b = ↑a
⊢ (Units.map ↑f) ⋯.unit = a
tactic: use (isUnit_of_map_unit f b (by rw [hb]; exact Units.isUnit _)).unit
state_before: case h
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
b : R
hb : f b = ↑a
⊢ (Units.map ↑f) ⋯.unit = a
state_after: case h.a
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
b : R
hb : f b = ↑a
⊢ ↑((Units.map ↑f) ⋯.unit) = ↑a
tactic: ext
state_before: case h.a
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Function.Surjective ⇑f
h : IsLocalRingHom f
a : Sˣ
b : R
hb : f b = ↑a
⊢ ↑((Units.map ↑f) ⋯.unit) = ↑a
state_after: no goals
tactic: exact hb
Theorem: Set.encard_exchange'
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b : α
ha : a ∉ s
hb : b ∈ s
⊢ (insert a s \ {b}).encard = s.encard
state_after: no goals
tactic: rw [← insert_diff_singleton_comm (by rintro rfl; exact ha hb), encard_exchange ha hb]
Theorem: MeasureTheory.BorelCantelli.martingalePart_process_ae_eq
File: Mathlib/Probability/Martingale/BorelCantelli.lean

Proof steps:
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
⊢ martingalePart (process s) ℱ μ n = ∑ k ∈ Finset.range n, ((s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k])
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
⊢ ∑ i ∈ Finset.range n, (process s (i + 1) - process s i - μ[process s (i + 1) - process s i|↑ℱ i]) =
    ∑ k ∈ Finset.range n, ((s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k])
tactic: simp only [martingalePart_eq_sum, process_zero, zero_add]
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n : ℕ
⊢ ∑ i ∈ Finset.range n, (process s (i + 1) - process s i - μ[process s (i + 1) - process s i|↑ℱ i]) =
    ∑ k ∈ Finset.range n, ((s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k])
state_after: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n k : ℕ
x✝ : k ∈ Finset.range n
⊢ process s (k + 1) - process s k - μ[process s (k + 1) - process s k|↑ℱ k] =
    (s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k]
tactic: refine Finset.sum_congr rfl fun k _ => ?_
state_before: Ω : Type u_1
m0 : MeasurableSpace Ω
μ✝ : Measure Ω
ℱ✝ : Filtration ℕ m0
f : ℕ → Ω → ℝ
ω : Ω
r : ℝ
R : ℝ≥0
s✝ : ℕ → Set Ω
ℱ : Filtration ℕ m0
μ : Measure Ω
s : ℕ → Set Ω
n k : ℕ
x✝ : k ∈ Finset.range n
⊢ process s (k + 1) - process s k - μ[process s (k + 1) - process s k|↑ℱ k] =
    (s (k + 1)).indicator 1 - μ[(s (k + 1)).indicator 1|↑ℱ k]
state_after: no goals
tactic: simp only [process, Finset.sum_range_succ_sub_sum]
Theorem: AddMonoidAlgebra.modOf_add_divOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

Proof steps:
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
g : G
⊢ x %ᵒᶠ g + of' k G g * (x /ᵒᶠ g) = x
state_after: no goals
tactic: rw [add_comm, divOf_add_modOf]
Theorem: himp_inf_distrib
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d✝ a b c d : α
⊢ d ≤ a ⇨ b ⊓ c ↔ d ≤ (a ⇨ b) ⊓ (a ⇨ c)
state_after: no goals
tactic: simp_rw [le_himp_iff, le_inf_iff, le_himp_iff]