1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.OuterMeasure.restrict_apply
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

tactic: simp [restrict, inter_comm t]
state_before: α : Type u_1
β : Type u_2
m✝ : OuterMeasure α
s t : Set α
m : OuterMeasure α
⊢ ((restrict s) m) t = m (t ∩ s)
state_after: no goals
Theorem: List.map_leftInverse_iff
File: Mathlib/Data/List/Basic.lean

tactic: injection h [x]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
g : β → α
h : LeftInverse (map f) (map g)
x : β
⊢ f (g x) = x
state_after: no goals
Theorem: sbtw_zero_one_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Sbtw, wbtw_zero_one_iff, Set.mem_Icc, Set.mem_Ioo]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ Sbtw R 0 x 1 ↔ x ∈ Set.Ioo 0 1
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (0 ≤ x ∧ x ≤ 1) ∧ x ≠ 0 ∧ x ≠ 1 ↔ 0 < x ∧ x < 1

tactic: exact
  ⟨fun h => ⟨h.1.1.lt_of_ne (Ne.symm h.2.1), h.1.2.lt_of_ne h.2.2⟩, fun h =>
    ⟨⟨h.1.le, h.2.le⟩, h.1.ne', h.2.ne⟩⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x : R
⊢ (0 ≤ x ∧ x ≤ 1) ∧ x ≠ 0 ∧ x ≠ 1 ↔ 0 < x ∧ x < 1
state_after: no goals
Theorem: Stream'.inits_core_eq
File: Mathlib/Data/Stream/Init.lean

tactic: unfold initsCore corecOn
state_before: α : Type u
β : Type v
δ : Type w
l : List α
s : Stream' α
⊢ initsCore l s = l :: initsCore (l ++ [s.head]) s.tail
state_after: α : Type u
β : Type v
δ : Type w
l : List α
s : Stream' α
⊢ corec
      (fun x =>
        match x with
        | (a, snd) => a)
      (fun p =>
        match p with
        | (l', s') => (l' ++ [s'.head], s'.tail))
      (l, s) =
    l ::
      corec
        (fun x =>
          match x with
          | (a, snd) => a)
        (fun p =>
          match p with
          | (l', s') => (l' ++ [s'.head], s'.tail))
        (l ++ [s.head], s.tail)

tactic: rw [corec_eq]
state_before: α : Type u
β : Type v
δ : Type w
l : List α
s : Stream' α
⊢ corec
      (fun x =>
        match x with
        | (a, snd) => a)
      (fun p =>
        match p with
        | (l', s') => (l' ++ [s'.head], s'.tail))
      (l, s) =
    l ::
      corec
        (fun x =>
          match x with
          | (a, snd) => a)
        (fun p =>
          match p with
          | (l', s') => (l' ++ [s'.head], s'.tail))
        (l ++ [s.head], s.tail)
state_after: no goals
Theorem: CategoryTheory.Limits.limLax_μ
File: Mathlib/CategoryTheory/Monoidal/Limits.lean

tactic: dsimp
state_before: J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F G : J ⥤ C
j j' : J
f : j ⟶ j'
⊢ ((Functor.const J).obj (limit F ⊗ limit G)).map f ≫ (fun j => limit.π F j ⊗ limit.π G j) j' =
    (fun j => limit.π F j ⊗ limit.π G j) j ≫ (F ⊗ G).map f
state_after: J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F G : J ⥤ C
j j' : J
f : j ⟶ j'
⊢ 𝟙 (limit F ⊗ limit G) ≫ (limit.π F j' ⊗ limit.π G j') = (limit.π F j ⊗ limit.π G j) ≫ (F.map f ⊗ G.map f)

tactic: simp only [Category.id_comp, ← tensor_comp, limit.w]
state_before: J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
F G : J ⥤ C
j j' : J
f : j ⟶ j'
⊢ 𝟙 (limit F ⊗ limit G) ≫ (limit.π F j' ⊗ limit.π G j') = (limit.π F j ⊗ limit.π G j) ≫ (F.map f ⊗ G.map f)
state_after: no goals
Theorem: Subgroup.mem_centralizer_iff_commutator_eq_one
File: Mathlib/GroupTheory/Subgroup/Centralizer.lean

tactic: simp only [mem_centralizer_iff, mul_inv_eq_iff_eq_mul, one_mul]
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
g : G
s : Set G
⊢ g ∈ centralizer s ↔ ∀ h ∈ s, h * g * h⁻¹ * g⁻¹ = 1
state_after: no goals
Theorem: UniqueFactorizationMonoid.factors_mul
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: refine
  factors_unique irreducible_of_factor
    (fun a ha =>
      (Multiset.mem_add.mp ha).by_cases (irreducible_of_factor _) (irreducible_of_factor _))
    ((factors_prod (mul_ne_zero hx hy)).trans ?_)
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ Multiset.Rel Associated (factors (x * y)) (factors x + factors y)
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y ~ᵤ (factors x + factors y).prod

tactic: rw [Multiset.prod_add]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y ~ᵤ (factors x + factors y).prod
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y ~ᵤ (factors x).prod * (factors y).prod

tactic: exact (Associated.mul_mul (factors_prod hx) (factors_prod hy)).symm
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ x * y ~ᵤ (factors x).prod * (factors y).prod
state_after: no goals
Theorem: SimpleGraph.isBridge_iff_adj_and_forall_walk_mem_edges
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [isBridge_iff, and_congr_right']
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ G.IsBridge s(v, w) ↔ G.Adj v w ∧ ∀ (p : G.Walk v w), s(v, w) ∈ p.edges
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ ¬(G \ fromEdgeSet {s(v, w)}).Reachable v w ↔ ∀ (p : G.Walk v w), s(v, w) ∈ p.edges

tactic: rw [reachable_delete_edges_iff_exists_walk, not_exists_not]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ ¬(G \ fromEdgeSet {s(v, w)}).Reachable v w ↔ ∀ (p : G.Walk v w), s(v, w) ∈ p.edges
state_after: no goals
Theorem: rank_fun
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: rw [rank_pi, Cardinal.sum_const', Cardinal.mk_fintype]
state_before: R S : Type u
M✝ : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η✝ : Type u₁'
φ : η✝ → Type u_1
inst✝¹⁷ : Ring R
inst✝¹⁶ : CommRing S
inst✝¹⁵ : AddCommGroup M✝
inst✝¹⁴ : AddCommGroup M'
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R M✝
inst✝¹¹ : Module R M'
inst✝¹⁰ : Module R M₁
inst✝⁹ : StrongRankCondition R
inst✝⁸ : Module.Free R M✝
inst✝⁷ : (i : η✝) → AddCommGroup (φ i)
inst✝⁶ : (i : η✝) → Module R (φ i)
inst✝⁵ : ∀ (i : η✝), Module.Free R (φ i)
inst✝⁴ : Fintype η✝
M η : Type u
inst✝³ : Fintype η
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : Module.Free R M
⊢ Module.rank R (η → M) = ↑(Fintype.card η) * Module.rank R M
state_after: no goals
Theorem: orderOf_le_of_pow_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rwa [isPeriodicPt_mul_iff_pow_eq_one]
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 : ℕ
hn : 0 < n
h : x ^ n = 1
⊢ IsPeriodicPt (fun x_1 => x * x_1) n 1
state_after: no goals
Theorem: Finset.Ico_subset_Ioo_left
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [← coe_subset, coe_Ico, coe_Ioo]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : a₁ < a₂
⊢ Ico a₂ b ⊆ Ioo a₁ b
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : a₁ < a₂
⊢ Set.Ico a₂ b ⊆ Set.Ioo a₁ b

tactic: exact Set.Ico_subset_Ioo_left h
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h : a₁ < a₂
⊢ Set.Ico a₂ b ⊆ Set.Ioo a₁ b
state_after: no goals
Theorem: Surreal.bddBelow_of_small
File: Mathlib/SetTheory/Surreal/Basic.lean

tactic: simpa using bddBelow_range_of_small (Subtype.val : s → Surreal.{u})
state_before: s : Set Surreal
inst✝ : Small.{u, u + 1} ↑s
⊢ BddBelow s
state_after: no goals
Theorem: Sym.cons_of_coe_eq
File: Mathlib/Data/Sym/Basic.lean

tactic: cases v
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a✝ b a : α
v : Vector α n
⊢ ↑(a ::ₛ ofVector v) = ↑(ofVector (a ::ᵥ v))
state_after: case mk
α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a✝ b a : α
val✝ : List α
property✝ : val✝.length = n
⊢ ↑(a ::ₛ ofVector ⟨val✝, property✝⟩) = ↑(ofVector (a ::ᵥ ⟨val✝, property✝⟩))

tactic: rfl
state_before: case mk
α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a✝ b a : α
val✝ : List α
property✝ : val✝.length = n
⊢ ↑(a ::ₛ ofVector ⟨val✝, property✝⟩) = ↑(ofVector (a ::ᵥ ⟨val✝, property✝⟩))
state_after: no goals
Theorem: FractionalIdeal.isNoetherian_zero
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: rw [coe_zero, le_bot_iff] at hI
state_before: R : Type u_1
inst✝⁵ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝² : CommRing R₁
K : Type u_4
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I : Submodule R₁ K
hI : I ≤ ↑0
⊢ I.FG
state_after: R : Type u_1
inst✝⁵ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝² : CommRing R₁
K : Type u_4
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I : Submodule R₁ K
hI : I = ⊥
⊢ I.FG

tactic: rw [hI]
state_before: R : Type u_1
inst✝⁵ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝² : CommRing R₁
K : Type u_4
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I : Submodule R₁ K
hI : I = ⊥
⊢ I.FG
state_after: R : Type u_1
inst✝⁵ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝² : CommRing R₁
K : Type u_4
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I : Submodule R₁ K
hI : I = ⊥
⊢ ⊥.FG

tactic: exact fg_bot
state_before: R : Type u_1
inst✝⁵ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝² : CommRing R₁
K : Type u_4
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I : Submodule R₁ K
hI : I = ⊥
⊢ ⊥.FG
state_after: no goals
Theorem: CategoryTheory.Presieve.factorsThruAlong_id
File: Mathlib/CategoryTheory/Sites/Coverage.lean

tactic: simp [FactorsThruAlong, FactorsThru]
state_before: C : Type u_2
D : Type ?u.1161
inst✝¹ : Category.{u_1, u_2} C
inst✝ : Category.{?u.1169, ?u.1161} D
X : C
S T : Presieve X
⊢ S.FactorsThruAlong T (𝟙 X) ↔ S.FactorsThru T
state_after: no goals
Theorem: zpow_one_add
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [zpow_add, zpow_one]
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
n : ℤ
⊢ a ^ (1 + n) = a * a ^ n
state_after: no goals
Theorem: Algebra.TensorProduct.basis_repr_symm_apply
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: rw [basis, LinearEquiv.coe_symm_mk]
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
i : ι
⊢ (basis A b).repr.symm (Finsupp.single i a) = a ⊗ₜ[R] b.repr.symm (Finsupp.single i 1)
state_after: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
i : ι
⊢ (basisAux A b).invFun (Finsupp.single i a) = a ⊗ₜ[R] b.repr.symm (Finsupp.single i 1)

tactic: simp [Equiv.uniqueProd_symm_apply, basisAux]
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
M : Type uM
ι : Type uι
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis ι R M
a : A
i : ι
⊢ (basisAux A b).invFun (Finsupp.single i a) = a ⊗ₜ[R] b.repr.symm (Finsupp.single i 1)
state_after: no goals
Theorem: Fin.castSucc_pred_add_one_eq
File: Mathlib/Data/Fin/Basic.lean

tactic: cases' a using cases with a
state_before: n m : ℕ
a : Fin (n + 1)
ha : a ≠ 0
⊢ (a.pred ha).castSucc + 1 = a
state_after: case zero
n m : ℕ
ha : 0 ≠ 0
⊢ (pred 0 ha).castSucc + 1 = 0

case succ
n m : ℕ
a : Fin n
ha : a.succ ≠ 0
⊢ (a.succ.pred ha).castSucc + 1 = a.succ

tactic: exact (ha rfl).elim
state_before: case zero
n m : ℕ
ha : 0 ≠ 0
⊢ (pred 0 ha).castSucc + 1 = 0
state_after: no goals

tactic: rw [pred_succ, coeSucc_eq_succ]
state_before: case succ
n m : ℕ
a : Fin n
ha : a.succ ≠ 0
⊢ (a.succ.pred ha).castSucc + 1 = a.succ
state_after: no goals
Theorem: Nat.Prime.not_coprime_iff_dvd
File: Mathlib/Data/Nat/Prime.lean

tactic: apply Iff.intro
state_before: n✝ m n : ℕ
⊢ ¬m.Coprime n ↔ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
state_after: case mp
n✝ m n : ℕ
⊢ ¬m.Coprime n → ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n

case mpr
n✝ m n : ℕ
⊢ (∃ p, Prime p ∧ p ∣ m ∧ p ∣ n) → ¬m.Coprime n

tactic: intro h
state_before: case mp
n✝ m n : ℕ
⊢ ¬m.Coprime n → ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
state_after: case mp
n✝ m n : ℕ
h : ¬m.Coprime n
⊢ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n

tactic: exact
  ⟨minFac (gcd m n), minFac_prime h, (minFac_dvd (gcd m n)).trans (gcd_dvd_left m n),
    (minFac_dvd (gcd m n)).trans (gcd_dvd_right m n)⟩
state_before: case mp
n✝ m n : ℕ
h : ¬m.Coprime n
⊢ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
state_after: no goals

tactic: intro h
state_before: case mpr
n✝ m n : ℕ
⊢ (∃ p, Prime p ∧ p ∣ m ∧ p ∣ n) → ¬m.Coprime n
state_after: case mpr
n✝ m n : ℕ
h : ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
⊢ ¬m.Coprime n

tactic: cases' h with p hp
state_before: case mpr
n✝ m n : ℕ
h : ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n
⊢ ¬m.Coprime n
state_after: case mpr.intro
n✝ m n p : ℕ
hp : Prime p ∧ p ∣ m ∧ p ∣ n
⊢ ¬m.Coprime n

tactic: apply Nat.not_coprime_of_dvd_of_dvd (Prime.one_lt hp.1) hp.2.1 hp.2.2
state_before: case mpr.intro
n✝ m n p : ℕ
hp : Prime p ∧ p ∣ m ∧ p ∣ n
⊢ ¬m.Coprime n
state_after: no goals
Theorem: List.ofFn_mul'
File: Mathlib/Data/List/OfFn.lean

tactic: rw [Nat.mul_add, Nat.mul_one]
state_before: α : Type u
m n : ℕ
f : Fin (m * n) → α
i : Fin n
j : Fin m
⊢ m * ↑i + m = m * (↑i + 1)
state_after: no goals

tactic: simp_rw [m.mul_comm, ofFn_mul, Fin.cast_mk]
state_before: α : Type u
m n : ℕ
f : Fin (m * n) → α
⊢ ofFn f = (ofFn fun i => ofFn fun j => f ⟨m * ↑i + ↑j, ⋯⟩).join
state_after: no goals
Theorem: le_iInf₂_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: simp_rw [le_iInf_iff]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : (i : ι) → κ i → α
⊢ a ≤ ⨅ i, ⨅ j, f i j ↔ ∀ (i : ι) (j : κ i), a ≤ f i j
state_after: no goals
Theorem: Subgroup.smul_inf
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

tactic: simp [SetLike.ext_iff, mem_pointwise_smul_iff_inv_smul_mem]
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Group α
inst✝ : MulDistribMulAction α G
a : α
S T : Subgroup G
⊢ a • (S ⊓ T) = a • S ⊓ a • T
state_after: no goals
Theorem: FractionalIdeal.absNorm_nonneg
File: Mathlib/RingTheory/FractionalIdeal/Norm.lean

tactic: dsimp [absNorm]
state_before: R : Type u_1
inst✝⁶ : CommRing R
inst✝⁵ : IsDedekindDomain R
inst✝⁴ : Module.Free ℤ R
inst✝³ : Module.Finite ℤ R
K : Type u_2
inst✝² : CommRing K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
I : FractionalIdeal R⁰ K
⊢ 0 ≤ absNorm I
state_after: R : Type u_1
inst✝⁶ : CommRing R
inst✝⁵ : IsDedekindDomain R
inst✝⁴ : Module.Free ℤ R
inst✝³ : Module.Finite ℤ R
K : Type u_2
inst✝² : CommRing K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
I : FractionalIdeal R⁰ K
⊢ 0 ≤ ↑(Ideal.absNorm I.num) / ↑|(Algebra.norm ℤ) ↑I.den|

tactic: positivity
state_before: R : Type u_1
inst✝⁶ : CommRing R
inst✝⁵ : IsDedekindDomain R
inst✝⁴ : Module.Free ℤ R
inst✝³ : Module.Finite ℤ R
K : Type u_2
inst✝² : CommRing K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
I : FractionalIdeal R⁰ K
⊢ 0 ≤ ↑(Ideal.absNorm I.num) / ↑|(Algebra.norm ℤ) ↑I.den|
state_after: no goals
Theorem: ciSup_of_empty
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [iSup_of_empty', csSup_empty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLinearOrderBot α
s : Set α
f✝ : ι → α
a : α
inst✝ : IsEmpty ι
f : ι → α
⊢ ⨆ i, f i = ⊥
state_after: no goals
Theorem: Turing.ToPartrec.Cont.then_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: induction' k with _ _ _ _ _ _ _ _ _ k_ih _ _ k_ih generalizing v <;>
  simp only [Cont.eval, Cont.then, bind_assoc, pure_bind, *]
state_before: k k' : Cont
v : List ℕ
⊢ (k.then k').eval v = k.eval v >>= k'.eval
state_after: case comp
k' : Cont
a✝¹ : Code
a✝ : Cont
k_ih : ∀ {v : List ℕ}, (a✝.then k').eval v = a✝.eval v >>= k'.eval
v : List ℕ
⊢ a✝¹.eval v >>= (a✝.then k').eval = a✝¹.eval v >>= fun x => a✝.eval x >>= k'.eval

case fix
k' : Cont
a✝¹ : Code
a✝ : Cont
k_ih : ∀ {v : List ℕ}, (a✝.then k').eval v = a✝.eval v >>= k'.eval
v : List ℕ
⊢ (if v.headI = 0 then a✝.eval v.tail >>= k'.eval else a✝¹.fix.eval v.tail >>= (a✝.then k').eval) =
    (if v.headI = 0 then a✝.eval v.tail else a✝¹.fix.eval v.tail >>= a✝.eval) >>= k'.eval

tactic: simp only [← k_ih]
state_before: case comp
k' : Cont
a✝¹ : Code
a✝ : Cont
k_ih : ∀ {v : List ℕ}, (a✝.then k').eval v = a✝.eval v >>= k'.eval
v : List ℕ
⊢ a✝¹.eval v >>= (a✝.then k').eval = a✝¹.eval v >>= fun x => a✝.eval x >>= k'.eval
state_after: no goals

tactic: split_ifs <;> [rfl; simp only [← k_ih, bind_assoc]]
state_before: case fix
k' : Cont
a✝¹ : Code
a✝ : Cont
k_ih : ∀ {v : List ℕ}, (a✝.then k').eval v = a✝.eval v >>= k'.eval
v : List ℕ
⊢ (if v.headI = 0 then a✝.eval v.tail >>= k'.eval else a✝¹.fix.eval v.tail >>= (a✝.then k').eval) =
    (if v.headI = 0 then a✝.eval v.tail else a✝¹.fix.eval v.tail >>= a✝.eval) >>= k'.eval
state_after: no goals
Theorem: Order.pred_le_iff_eq_or_le
File: Mathlib/Order/SuccPred/Basic.lean

tactic: by_cases ha : IsMin a
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : IsMin a
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b

case neg
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b

tactic: rw [ha.pred_eq, or_iff_right_of_imp ge_of_eq]
state_before: case pos
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : IsMin a
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b
state_after: no goals

tactic: rw [← pred_lt_iff_of_not_isMin ha, le_iff_eq_or_lt, eq_comm]
state_before: case neg
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b
state_after: no goals
Theorem: Polynomial.annIdealGenerator_eq_zero_iff
File: Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean

tactic: simp only [annIdealGenerator, mul_eq_zero, IsPrincipal.eq_bot_iff_generator_eq_zero,
  Polynomial.C_eq_zero, inv_eq_zero, Polynomial.leadingCoeff_eq_zero, or_self_iff]
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : A
⊢ annIdealGenerator 𝕜 a = 0 ↔ annIdeal 𝕜 a = ⊥
state_after: no goals
Theorem: Isometry.preimage_setOf_dist
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: ext y
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
x : α
p : ℝ → Prop
⊢ f ⁻¹' {y | p (dist y (f x))} = {y | p (dist y x)}
state_after: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
x : α
p : ℝ → Prop
y : α
⊢ y ∈ f ⁻¹' {y | p (dist y (f x))} ↔ y ∈ {y | p (dist y x)}

tactic: simp [hf.dist_eq]
state_before: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
x : α
p : ℝ → Prop
y : α
⊢ y ∈ f ⁻¹' {y | p (dist y (f x))} ↔ y ∈ {y | p (dist y x)}
state_after: no goals
Theorem: Finsupp.card_support_le_one'
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp only [card_le_one_iff_subset_singleton, support_subset_singleton']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
a a' : α
b : M
inst✝ : Nonempty α
f : α →₀ M
⊢ f.support.card ≤ 1 ↔ ∃ a b, f = single a b
state_after: no goals
Theorem: Nat.bit_val
File: Mathlib/Data/Nat/Bits.lean

tactic: cases b
state_before: m n✝ : ℕ
b : Bool
n : ℕ
⊢ bit b n = 2 * n + bif b then 1 else 0
state_after: case false
m n✝ n : ℕ
⊢ bit false n = 2 * n + bif false then 1 else 0

case true
m n✝ n : ℕ
⊢ bit true n = 2 * n + bif true then 1 else 0

tactic: apply bit0_val
state_before: case false
m n✝ n : ℕ
⊢ bit false n = 2 * n + bif false then 1 else 0
state_after: no goals

tactic: apply bit1_val
state_before: case true
m n✝ n : ℕ
⊢ bit true n = 2 * n + bif true then 1 else 0
state_after: no goals
Theorem: AddConstMapClass.map_nat_add'
File: Mathlib/Algebra/AddConstMap/Basic.lean

tactic: simpa using map_nsmul_add f n x
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddCommMonoidWithOne G
inst✝¹ : AddMonoid H
inst✝ : AddConstMapClass F G H 1 b
f : F
n : ℕ
x : G
⊢ f (↑n + x) = f x + n • b
state_after: no goals
Theorem: MeasureTheory.Measure.measurable_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases h : HaveLebesgueDecomposition μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
⊢ Measurable (μ.rnDeriv ν)
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : μ.HaveLebesgueDecomposition ν
⊢ Measurable (μ.rnDeriv ν)

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : ¬μ.HaveLebesgueDecomposition ν
⊢ Measurable (μ.rnDeriv ν)

tactic: exact (haveLebesgueDecomposition_spec μ ν).1
state_before: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : μ.HaveLebesgueDecomposition ν
⊢ Measurable (μ.rnDeriv ν)
state_after: no goals

tactic: rw [rnDeriv_of_not_haveLebesgueDecomposition h]
state_before: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : ¬μ.HaveLebesgueDecomposition ν
⊢ Measurable (μ.rnDeriv ν)
state_after: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : ¬μ.HaveLebesgueDecomposition ν
⊢ Measurable 0

tactic: exact measurable_zero
state_before: case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : ¬μ.HaveLebesgueDecomposition ν
⊢ Measurable 0
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.restrictNonposSeq_succ
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [restrictNonposSeq]
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n : ℕ
⊢ MeasureTheory.SignedMeasure.restrictNonposSeq s i n.succ =
    MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \ ⋃ k, ⋃ (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k)
state_after: no goals