1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.Measure.InnerRegularWRT.exists_subset_lt_add
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: rcases eq_or_ne (μ U) 0 with h₀ | h₀
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε
state_after: case inl
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U = 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε

case inr
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U ≠ 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε

tactic: refine ⟨∅, empty_subset _, h0, ?_⟩
state_before: case inl
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U = 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε
state_after: case inl
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U = 0
⊢ μ U < μ ∅ + ε

tactic: rwa [measure_empty, h₀, zero_add, pos_iff_ne_zero]
state_before: case inl
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U = 0
⊢ μ U < μ ∅ + ε
state_after: no goals

tactic: rcases H hU _ (ENNReal.sub_lt_self hμU h₀ hε) with ⟨K, hKU, hKc, hrK⟩
state_before: case inr
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U ≠ 0
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε
state_after: case inr.intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U ≠ 0
K : Set α
hKU : K ⊆ U
hKc : p K
hrK : μ U - ε < μ K
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε

tactic: exact ⟨K, hKU, hKc, ENNReal.lt_add_of_sub_lt_right (Or.inl hμU) hrK⟩
state_before: case inr.intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : μ.InnerRegularWRT p q
h0 : p ∅
hU : q U
hμU : μ U ≠ ⊤
hε : ε ≠ 0
h₀ : μ U ≠ 0
K : Set α
hKU : K ⊆ U
hKc : p K
hrK : μ U - ε < μ K
⊢ ∃ K ⊆ U, p K ∧ μ U < μ K + ε
state_after: no goals
Theorem: SeparationQuotient.tendsto_lift₂_nhdsWithin
File: Mathlib/Topology/Inseparable.lean

tactic: rw [nhdsWithin, ← map_prod_map_mk_nhds, ← Filter.push_pull, comap_principal]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s✝ : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
s : Set (SeparationQuotient X × SeparationQuotient Y)
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf)) (𝓝[s] (mk x, mk y)) l ↔ Tendsto (uncurry f) (𝓝[Prod.map mk mk ⁻¹' s] (x, y)) l
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s✝ : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
s : Set (SeparationQuotient X × SeparationQuotient Y)
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf)) (Filter.map (Prod.map mk mk) (𝓝 (x, y) ⊓ 𝓟 (Prod.map mk mk ⁻¹' s))) l ↔
    Tendsto (uncurry f) (𝓝[Prod.map mk mk ⁻¹' s] (x, y)) l

tactic: rfl
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s✝ : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
s : Set (SeparationQuotient X × SeparationQuotient Y)
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf)) (Filter.map (Prod.map mk mk) (𝓝 (x, y) ⊓ 𝓟 (Prod.map mk mk ⁻¹' s))) l ↔
    Tendsto (uncurry f) (𝓝[Prod.map mk mk ⁻¹' s] (x, y)) l
state_after: no goals
Theorem: smul_ite_zero
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: split_ifs <;> simp
state_before: M : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
inst✝² : Zero A
inst✝¹ : SMulZeroClass M A
p : Prop
inst✝ : Decidable p
a : M
b : A
⊢ (a • if p then b else 0) = if p then a • b else 0
state_after: no goals
Theorem: Real.abs_sinh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: cases le_total x 0 <;> simp [abs_of_nonneg, abs_of_nonpos, *]
state_before: x✝ y z x : ℝ
⊢ |sinh x| = sinh |x|
state_after: no goals
Theorem: Primrec.dom_bool
File: Mathlib/Computability/Primrec.lean

tactic: cases b <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : Bool → α
b : Bool
⊢ (bif id b then f true else f false) = f b
state_after: no goals
Theorem: Prop.isCoatom_iff
File: Mathlib/Order/Atoms.lean

tactic: simp [IsCoatom, show ⊤ = True from rfl, fun q r : Prop => show q < r ↔ _ ∧ _ from .rfl]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
p : Prop
⊢ IsCoatom p ↔ ¬p
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
p : Prop
⊢ ¬p → ∀ (b : Prop), (p → b) → b → ¬p → b

tactic: tauto
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
p : Prop
⊢ ¬p → ∀ (b : Prop), (p → b) → b → ¬p → b
state_after: no goals
Theorem: Quiver.Hom.cast_eq_cast
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [hu, hv]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
⊢ (u ⟶ v) = (u' ⟶ v')
state_after: no goals

tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
⊢ cast hu hv e = _root_.cast ⋯ e
state_after: U : Type u_1
inst✝ : Quiver U
u' v' : U
e : u' ⟶ v'
⊢ cast ⋯ ⋯ e = _root_.cast ⋯ e

tactic: rfl
state_before: U : Type u_1
inst✝ : Quiver U
u' v' : U
e : u' ⟶ v'
⊢ cast ⋯ ⋯ e = _root_.cast ⋯ e
state_after: no goals
Theorem: strongRankCondition_iff_succ
File: Mathlib/LinearAlgebra/InvariantBasisNumber.lean

tactic: refine ⟨fun h n => fun f hf => ?_, fun h => ⟨@fun n m f hf => ?_⟩⟩
state_before: R : Type u
inst✝ : Semiring R
⊢ StrongRankCondition R ↔ ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ⇑f
state_after: case refine_1
R : Type u
inst✝ : Semiring R
h : StrongRankCondition R
n : ℕ
f : (Fin (n + 1) → R) →ₗ[R] Fin n → R
hf : Injective ⇑f
⊢ False

case refine_2
R : Type u
inst✝ : Semiring R
h : ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ⇑f
n m : ℕ
f : (Fin n → R) →ₗ[R] Fin m → R
hf : Injective ⇑f
⊢ n ≤ m

tactic: letI : StrongRankCondition R := h
state_before: case refine_1
R : Type u
inst✝ : Semiring R
h : StrongRankCondition R
n : ℕ
f : (Fin (n + 1) → R) →ₗ[R] Fin n → R
hf : Injective ⇑f
⊢ False
state_after: case refine_1
R : Type u
inst✝ : Semiring R
h : StrongRankCondition R
n : ℕ
f : (Fin (n + 1) → R) →ₗ[R] Fin n → R
hf : Injective ⇑f
this : StrongRankCondition R := h
⊢ False

tactic: exact Nat.not_succ_le_self n (le_of_fin_injective R f hf)
state_before: case refine_1
R : Type u
inst✝ : Semiring R
h : StrongRankCondition R
n : ℕ
f : (Fin (n + 1) → R) →ₗ[R] Fin n → R
hf : Injective ⇑f
this : StrongRankCondition R := h
⊢ False
state_after: no goals

tactic: by_contra H
state_before: case refine_2
R : Type u
inst✝ : Semiring R
h : ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ⇑f
n m : ℕ
f : (Fin n → R) →ₗ[R] Fin m → R
hf : Injective ⇑f
⊢ n ≤ m
state_after: case refine_2
R : Type u
inst✝ : Semiring R
h : ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ⇑f
n m : ℕ
f : (Fin n → R) →ₗ[R] Fin m → R
hf : Injective ⇑f
H : ¬n ≤ m
⊢ False

tactic: exact
  h m (f.comp (Function.ExtendByZero.linearMap R (Fin.castLE (not_le.1 H))))
    (hf.comp (Function.extend_injective (Fin.strictMono_castLE _).injective _))
state_before: case refine_2
R : Type u
inst✝ : Semiring R
h : ∀ (n : ℕ) (f : (Fin (n + 1) → R) →ₗ[R] Fin n → R), ¬Injective ⇑f
n m : ℕ
f : (Fin n → R) →ₗ[R] Fin m → R
hf : Injective ⇑f
H : ¬n ≤ m
⊢ False
state_after: no goals
Theorem: iter_deriv_inv
File: Mathlib/Analysis/Calculus/Deriv/ZPow.lean

tactic: simpa only [zpow_neg_one, Int.cast_neg, Int.cast_one] using iter_deriv_zpow (-1) x k
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m : ℤ
k : ℕ
x : 𝕜
⊢ deriv^[k] Inv.inv x = (∏ i ∈ Finset.range k, (-1 - ↑i)) * x ^ (-1 - ↑k)
state_after: no goals
Theorem: CategoryTheory.leftAdjointMate_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: apply_fun tensorLeftHomEquiv _ (ᘁX) X _
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (X ◁ ᘁf) ≫ ε_ (ᘁX) X = f ▷ ᘁY ≫ ε_ (ᘁY) Y
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) ((X ◁ ᘁf) ≫ ε_ (ᘁX) X) =
    (tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) (f ▷ ᘁY ≫ ε_ (ᘁY) Y)

tactic: simp
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) ((X ◁ ᘁf) ≫ ε_ (ᘁX) X) =
    (tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) (f ▷ ᘁY ≫ ε_ (ᘁY) Y)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.negMap_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [negMap_eq, neg_of_Z_ne_zero hPz, smul_eq _ <| Ne.isUnit hPz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.negMap ⟦P⟧ = ⟦![P x / P z ^ 2, W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3), 1]⟧
state_after: no goals
Theorem: SatisfiesM.map
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

tactic: let ⟨x', hx⟩ := hx
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
⊢ SatisfiesM q (f <$> x)
state_after: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ SatisfiesM q (f <$> x)

tactic: refine ⟨(fun ⟨a, h⟩ => ⟨f a, hf h⟩) <$> x', ?_⟩
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ SatisfiesM q (f <$> x)
state_after: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> x

tactic: rw [← hx]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> x
state_after: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> Subtype.val <$> x'

tactic: simp [← comp_map, Function.comp_def]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p : α → Prop
α✝ : Type u_1
q : α✝ → Prop
f : α → α✝
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x : m α
hx✝ : SatisfiesM p x
hf : ∀ {a : α}, p a → q (f a)
x' : m { a // p a }
hx : Subtype.val <$> x' = x
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨f a, ⋯⟩) <$>
        x' =
    f <$> Subtype.val <$> x'
state_after: no goals
Theorem: mulRight_bound
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [mul_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NonUnitalSeminormedRing α
x y : α
⊢ ‖(AddMonoidHom.mulRight x) y‖ ≤ ‖x‖ * ‖y‖
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NonUnitalSeminormedRing α
x y : α
⊢ ‖(AddMonoidHom.mulRight x) y‖ ≤ ‖y‖ * ‖x‖

tactic: exact norm_mul_le y x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NonUnitalSeminormedRing α
x y : α
⊢ ‖(AddMonoidHom.mulRight x) y‖ ≤ ‖y‖ * ‖x‖
state_after: no goals
Theorem: PerfectionMap.mk'
File: Mathlib/RingTheory/Perfection.lean

tactic: simp [hfg, hx]
state_before: p : ℕ
inst✝⁵ : Fact (Nat.Prime p)
R : Type u₁
inst✝⁴ : CommSemiring R
inst✝³ : CharP R p
P : Type u₃
inst✝² : CommSemiring P
inst✝¹ : CharP P p
inst✝ : PerfectRing P p
f : P →+* R
g : P ≃+* Ring.Perfection R p
hfg : (Perfection.lift p P R) f = ↑g
y : ℕ → R
hy : ∀ (n : ℕ), y (n + 1) ^ p = y n
x : P
hx : g x = ⟨y, hy⟩
n : ℕ
⊢ (Perfection.coeff R p n) (((Perfection.lift p P R) f) x) = (Perfection.coeff R p n) ⟨y, hy⟩
state_after: no goals
Theorem: Homeomorph.quotientMap
File: Mathlib/Topology/Homeomorph.lean

tactic: simp only [self_comp_symm, QuotientMap.id]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
⊢ QuotientMap (⇑h ∘ ⇑h.symm)
state_after: no goals
Theorem: Mathlib.Meta.Finset.univ_eq_elems
File: Mathlib/Tactic/NormNum/BigOperators.lean

tactic: ext x
state_before: α : Type u_1
inst✝ : Fintype α
elems : Finset α
complete : ∀ (x : α), x ∈ elems
⊢ Finset.univ = elems
state_after: case a
α : Type u_1
inst✝ : Fintype α
elems : Finset α
complete : ∀ (x : α), x ∈ elems
x : α
⊢ x ∈ Finset.univ ↔ x ∈ elems

tactic: simpa using complete x
state_before: case a
α : Type u_1
inst✝ : Fintype α
elems : Finset α
complete : ∀ (x : α), x ∈ elems
x : α
⊢ x ∈ Finset.univ ↔ x ∈ elems
state_after: no goals
Theorem: LieModule.traceForm_lieInvariant
File: Mathlib/Algebra/Lie/TraceForm.lean

tactic: intro x y z
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
⊢ LinearMap.BilinForm.lieInvariant L (traceForm R L M)
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y z : L
⊢ ((traceForm R L M) ⁅x, y⁆) z = -((traceForm R L M) y) ⁅x, z⁆

tactic: rw [← lie_skew, map_neg, LinearMap.neg_apply, LieModule.traceForm_apply_lie_apply R L M]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : Module.Free R M
inst✝ : Module.Finite R M
x y z : L
⊢ ((traceForm R L M) ⁅x, y⁆) z = -((traceForm R L M) y) ⁅x, z⁆
state_after: no goals
Theorem: Finset.prod_attach
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: classical rw [← prod_image Subtype.coe_injective.injOn, attach_image_val]
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 β
s : Finset α
f : α → β
⊢ ∏ x ∈ s.attach, f ↑x = ∏ x ∈ s, f x
state_after: no goals

tactic: rw [← prod_image Subtype.coe_injective.injOn, attach_image_val]
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 β
s : Finset α
f : α → β
⊢ ∏ x ∈ s.attach, f ↑x = ∏ x ∈ s, f x
state_after: no goals
Theorem: Set.not_mem_uIoc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simp only [uIoc_eq_union, mem_union, mem_Ioc, not_lt, ← not_le]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ a ∉ Ι b c ↔ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ ¬(¬a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ a ≤ b) ↔ a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ ¬a ≤ b

tactic: tauto
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ ¬(¬a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ a ≤ b) ↔ a ≤ b ∧ a ≤ c ∨ ¬a ≤ c ∧ ¬a ≤ b
state_after: no goals
Theorem: MeasureTheory.measure_compl₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← measure_add_measure_compl₀ h, ENNReal.add_sub_cancel_left hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : NullMeasurableSet s μ
hs : μ s ≠ ⊤
⊢ μ sᶜ = μ univ - μ s
state_after: no goals
Theorem: CategoryTheory.mono_comp
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: constructor
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z
inst✝ : Mono g
⊢ Mono (f ≫ g)
state_after: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z
inst✝ : Mono g
⊢ ∀ {Z_1 : C} (g_1 h : Z_1 ⟶ X), g_1 ≫ f ≫ g = h ≫ f ≫ g → g_1 = h

tactic: intro Z a b w
state_before: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z
inst✝ : Mono g
⊢ ∀ {Z_1 : C} (g_1 h : Z_1 ⟶ X), g_1 ≫ f ≫ g = h ≫ f ≫ g → g_1 = h
state_after: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b

tactic: apply (cancel_mono f).1
state_before: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b
state_after: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a ≫ f = b ≫ f

tactic: apply (cancel_mono g).1
state_before: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a ≫ f = b ≫ f
state_after: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ (a ≫ f) ≫ g = (b ≫ f) ≫ g

tactic: simpa using w
state_before: case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ (a ≫ f) ≫ g = (b ≫ f) ≫ g
state_after: no goals
Theorem: Submodule.mem_sSup_of_mem
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: have := le_sSup hs
state_before: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
state_after: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
this : s ≤ sSup S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S

tactic: rw [LE.le] at this
state_before: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
this : s ≤ sSup S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
state_after: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
this : Preorder.toLE.1 s (sSup S)
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S

tactic: exact this
state_before: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
this : Preorder.toLE.1 s (sSup S)
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
state_after: no goals
Theorem: leOnePart_eq_one
File: Mathlib/Algebra/Order/Group/PosPart.lean

tactic: simp [leOnePart_eq_one']
state_before: α : Type u_1
β : Type u_2
inst✝³ : Lattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ a⁻ᵐ = 1 ↔ 1 ≤ a
state_after: no goals
Theorem: div_neg_eq_neg_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← inv_eq_one_div, division_def]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ b / -a = b * (1 / -a)
state_after: no goals

tactic: rw [one_div_neg_eq_neg_one_div]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ b * (1 / -a) = b * -(1 / a)
state_after: no goals

tactic: rw [neg_mul_eq_mul_neg]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ b * -(1 / a) = -(b * (1 / a))
state_after: no goals

tactic: rw [mul_one_div]
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -(b * (1 / a)) = -(b / a)
state_after: no goals