1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LieAlgebra.nilpotent_of_nilpotent_quotient
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: suffices LieModule.IsNilpotent R L (L ⧸ I) by
  exact LieModule.nilpotentOfNilpotentQuotient R L L h₁ this
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
⊢ IsNilpotent R L
state_after: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
⊢ LieModule.IsNilpotent R L (L ⧸ I)

tactic: obtain ⟨k, hk⟩ := h₂
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
⊢ LieModule.IsNilpotent R L (L ⧸ I)
state_after: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
k : ℕ
hk : lowerCentralSeries R (L ⧸ I) (L ⧸ I) k = ⊥
⊢ LieModule.IsNilpotent R L (L ⧸ I)

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
k : ℕ
hk : lowerCentralSeries R (L ⧸ I) (L ⧸ I) k = ⊥
⊢ LieModule.IsNilpotent R L (L ⧸ I)
state_after: case h
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
k : ℕ
hk : lowerCentralSeries R (L ⧸ I) (L ⧸ I) k = ⊥
⊢ lowerCentralSeries R L (L ⧸ I) k = ⊥

tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff, coe_lowerCentralSeries_ideal_quot_eq, hk]
state_before: case h
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
k : ℕ
hk : lowerCentralSeries R (L ⧸ I) (L ⧸ I) k = ⊥
⊢ lowerCentralSeries R L (L ⧸ I) k = ⊥
state_after: no goals

tactic: exact LieModule.nilpotentOfNilpotentQuotient R L L h₁ this
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
this : LieModule.IsNilpotent R L (L ⧸ I)
⊢ IsNilpotent R L
state_after: no goals
Theorem: uniformEquicontinuous_iInf_dom
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp_rw [uniformEquicontinuous_iff_uniformContinuous (uβ := _)] at hk ⊢
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace β'
F : ι → β' → α
k : κ
hk : UniformEquicontinuous F
⊢ UniformEquicontinuous F
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace β'
F : ι → β' → α
k : κ
hk : UniformContinuous (⇑UniformFun.ofFun ∘ swap F)
⊢ UniformContinuous (⇑UniformFun.ofFun ∘ swap F)

tactic: exact uniformContinuous_iInf_dom hk
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
u : κ → UniformSpace β'
F : ι → β' → α
k : κ
hk : UniformContinuous (⇑UniformFun.ofFun ∘ swap F)
⊢ UniformContinuous (⇑UniformFun.ofFun ∘ swap F)
state_after: no goals
Theorem: maximals_singleton
File: Mathlib/Order/Minimal.lean

tactic: rintro b (rfl : b = a)
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
⊢ ∀ ⦃b : α⦄, b ∈ {a} → r a b → r b a
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
b✝ b : α
⊢ r b b → r b b

tactic: exact id
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
b✝ b : α
⊢ r b b → r b b
state_after: no goals
Theorem: measurableSet_of_differentiableAt
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

tactic: have : IsComplete (univ : Set (E →L[𝕜] F)) := complete_univ
state_before: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
⊢ MeasurableSet {x | DifferentiableAt 𝕜 f x}
state_after: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
this : IsComplete univ
⊢ MeasurableSet {x | DifferentiableAt 𝕜 f x}

tactic: convert measurableSet_of_differentiableAt_of_isComplete 𝕜 f this
state_before: 𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
this : IsComplete univ
⊢ MeasurableSet {x | DifferentiableAt 𝕜 f x}
state_after: case h.e'_3.h.e'_2.h.a
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
this : IsComplete univ
x✝ : E
⊢ DifferentiableAt 𝕜 f x✝ ↔ DifferentiableAt 𝕜 f x✝ ∧ fderiv 𝕜 f x✝ ∈ univ

tactic: simp
state_before: case h.e'_3.h.e'_2.h.a
𝕜 : Type u_1
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
this : IsComplete univ
x✝ : E
⊢ DifferentiableAt 𝕜 f x✝ ↔ DifferentiableAt 𝕜 f x✝ ∧ fderiv 𝕜 f x✝ ∈ univ
state_after: no goals
Theorem: Finset.gcd_mul_right
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: refine s.induction_on ?_ ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (s.gcd fun x => f x * a) = s.gcd f * normalize a
state_after: case refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∅.gcd fun x => f x * a) = ∅.gcd f * normalize a

case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ ∀ ⦃a_1 : β⦄ {s : Finset β},
    a_1 ∉ s →
      (s.gcd fun x => f x * a) = s.gcd f * normalize a →
        ((insert a_1 s).gcd fun x => f x * a) = (insert a_1 s).gcd f * normalize a

tactic: simp
state_before: case refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∅.gcd fun x => f x * a) = ∅.gcd f * normalize a
state_after: no goals

tactic: intro b t _ h
state_before: case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ ∀ ⦃a_1 : β⦄ {s : Finset β},
    a_1 ∉ s →
      (s.gcd fun x => f x * a) = s.gcd f * normalize a →
        ((insert a_1 s).gcd fun x => f x * a) = (insert a_1 s).gcd f * normalize a
state_after: case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : b ∉ t
h : (t.gcd fun x => f x * a) = t.gcd f * normalize a
⊢ ((insert b t).gcd fun x => f x * a) = (insert b t).gcd f * normalize a

tactic: rw [gcd_insert, gcd_insert, h, ← gcd_mul_right]
state_before: case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : b ∉ t
h : (t.gcd fun x => f x * a) = t.gcd f * normalize a
⊢ ((insert b t).gcd fun x => f x * a) = (insert b t).gcd f * normalize a
state_after: case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : b ∉ t
h : (t.gcd fun x => f x * a) = t.gcd f * normalize a
⊢ GCDMonoid.gcd (f b * a) (t.gcd f * normalize a) = GCDMonoid.gcd (f b * a) (t.gcd f * a)

tactic: apply ((normalize_associated a).mul_left _).gcd_eq_right
state_before: case refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : b ∉ t
h : (t.gcd fun x => f x * a) = t.gcd f * normalize a
⊢ GCDMonoid.gcd (f b * a) (t.gcd f * normalize a) = GCDMonoid.gcd (f b * a) (t.gcd f * a)
state_after: no goals
Theorem: Nat.card_units_zmod_lt_sub_one
File: Mathlib/Data/Nat/Totient.lean

tactic: haveI : NeZero p := ⟨(pos_of_gt hp).ne'⟩
state_before: p : ℕ
hp : 1 < p
inst✝ : Fintype (ZMod p)ˣ
⊢ Fintype.card (ZMod p)ˣ ≤ p - 1
state_after: p : ℕ
hp : 1 < p
inst✝ : Fintype (ZMod p)ˣ
this : NeZero p
⊢ Fintype.card (ZMod p)ˣ ≤ p - 1

tactic: rw [ZMod.card_units_eq_totient p]
state_before: p : ℕ
hp : 1 < p
inst✝ : Fintype (ZMod p)ˣ
this : NeZero p
⊢ Fintype.card (ZMod p)ˣ ≤ p - 1
state_after: p : ℕ
hp : 1 < p
inst✝ : Fintype (ZMod p)ˣ
this : NeZero p
⊢ φ p ≤ p - 1

tactic: exact Nat.le_sub_one_of_lt (Nat.totient_lt p hp)
state_before: p : ℕ
hp : 1 < p
inst✝ : Fintype (ZMod p)ˣ
this : NeZero p
⊢ φ p ≤ p - 1
state_after: no goals
Theorem: IsUnit.div_mul_right
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [mul_comm, h.div_mul_left]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b✝ c d : α
h : IsUnit a
b : α
⊢ a / (a * b) = 1 / b
state_after: no goals
Theorem: CliffordAlgebra.contractRight_comm
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: rw [contractRight_eq, contractRight_eq, contractRight_eq, contractRight_eq, reverse_reverse,
  reverse_reverse, contractLeft_comm, map_neg]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : CliffordAlgebra Q
⊢ (contractRight ((contractRight x) d)) d' = -(contractRight ((contractRight x) d')) d
state_after: no goals
Theorem: seq_bind_eq
File: Mathlib/Control/Basic.lean

tactic: rw [← bind_pure_comp, bind_assoc]
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : β → m γ
f : α → β
⊢ f <$> x >>= g = x >>= g ∘ f
state_after: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : β → m γ
f : α → β
⊢ (x >>= fun x => pure (f x) >>= g) = x >>= g ∘ f

tactic: simp [pure_bind, Function.comp_def]
state_before: α β γ : Type u
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
x : m α
g : β → m γ
f : α → β
⊢ (x >>= fun x => pure (f x) >>= g) = x >>= g ∘ f
state_after: no goals
Theorem: List.formPerm_apply_head
File: Mathlib/GroupTheory/Perm/List.lean

tactic: simp [formPerm_apply_of_not_mem h.not_mem]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
xs : List α
h : (x :: y :: xs).Nodup
⊢ (x :: y :: xs).formPerm x = y
state_after: no goals
Theorem: Matrix.fromBlocks_mulVec
File: Mathlib/Data/Matrix/Block.lean

tactic: ext i
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : l ⊕ m → α
⊢ fromBlocks A B C D *ᵥ x = Sum.elim (A *ᵥ x ∘ Sum.inl + B *ᵥ x ∘ Sum.inr) (C *ᵥ x ∘ Sum.inl + D *ᵥ x ∘ Sum.inr)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : l ⊕ m → α
i : n ⊕ o
⊢ (fromBlocks A B C D *ᵥ x) i = Sum.elim (A *ᵥ x ∘ Sum.inl + B *ᵥ x ∘ Sum.inr) (C *ᵥ x ∘ Sum.inl + D *ᵥ x ∘ Sum.inr) i

tactic: cases i <;> simp [mulVec, dotProduct]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝² : Fintype l
inst✝¹ : Fintype m
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
x : l ⊕ m → α
i : n ⊕ o
⊢ (fromBlocks A B C D *ᵥ x) i = Sum.elim (A *ᵥ x ∘ Sum.inl + B *ᵥ x ∘ Sum.inr) (C *ᵥ x ∘ Sum.inl + D *ᵥ x ∘ Sum.inr) i
state_after: no goals
Theorem: SimpleGraph.incMatrix_apply'
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: unfold incMatrix Set.indicator
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝³ : Zero R
inst✝² : One R
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a : α
e : Sym2 α
⊢ incMatrix R G a e = if e ∈ G.incidenceSet a then 1 else 0
state_after: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝³ : Zero R
inst✝² : One R
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a : α
e : Sym2 α
⊢ (if e ∈ G.incidenceSet a then 1 e else 0) = if e ∈ G.incidenceSet a then 1 else 0

tactic: convert rfl
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝³ : Zero R
inst✝² : One R
inst✝¹ : DecidableEq α
inst✝ : DecidableRel G.Adj
a : α
e : Sym2 α
⊢ (if e ∈ G.incidenceSet a then 1 e else 0) = if e ∈ G.incidenceSet a then 1 else 0
state_after: no goals
Theorem: CategoryTheory.Limits.image.isoStrongEpiMono_hom_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: dsimp [isoStrongEpiMono]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasStrongEpiMonoFactorisations C
X Y : C
f : X ⟶ Y
I' : C
e : X ⟶ I'
m : I' ⟶ Y
comm : e ≫ m = f
inst✝¹ : StrongEpi e
inst✝ : Mono m
⊢ (isoStrongEpiMono e m comm).hom ≫ ι f = m
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasStrongEpiMonoFactorisations C
X Y : C
f : X ⟶ Y
I' : C
e : X ⟶ I'
m : I' ⟶ Y
comm : e ≫ m = f
inst✝¹ : StrongEpi e
inst✝ : Mono m
⊢ (StrongEpiMonoFactorisation.mk (MonoFactorisation.mk I' m e ⋯)).toMonoIsImage.lift (Image.monoFactorisation f) ≫ ι f =
    m

tactic: apply IsImage.lift_fac
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasStrongEpiMonoFactorisations C
X Y : C
f : X ⟶ Y
I' : C
e : X ⟶ I'
m : I' ⟶ Y
comm : e ≫ m = f
inst✝¹ : StrongEpi e
inst✝ : Mono m
⊢ (StrongEpiMonoFactorisation.mk (MonoFactorisation.mk I' m e ⋯)).toMonoIsImage.lift (Image.monoFactorisation f) ≫ ι f =
    m
state_after: no goals
Theorem: MeasureTheory.integrable_left_of_integrable_add_of_nonneg
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: refine h_int.mono' h_meas ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : 0 ≤ᶠ[ae μ] f
hg : 0 ≤ᶠ[ae μ] g
h_int : Integrable (f + g) μ
⊢ Integrable f μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : 0 ≤ᶠ[ae μ] f
hg : 0 ≤ᶠ[ae μ] g
h_int : Integrable (f + g) μ
⊢ ∀ᵐ (a : α) ∂μ, ‖f a‖ ≤ (f + g) a

tactic: filter_upwards [hf, hg] with a haf hag
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : 0 ≤ᶠ[ae μ] f
hg : 0 ≤ᶠ[ae μ] g
h_int : Integrable (f + g) μ
⊢ ∀ᵐ (a : α) ∂μ, ‖f a‖ ≤ (f + g) a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : 0 ≤ᶠ[ae μ] f
hg : 0 ≤ᶠ[ae μ] g
h_int : Integrable (f + g) μ
a : α
haf : 0 a ≤ f a
hag : 0 a ≤ g a
⊢ ‖f a‖ ≤ (f + g) a

tactic: exact (Real.norm_of_nonneg haf).symm ▸ le_add_of_nonneg_right hag
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : α → ℝ
h_meas : AEStronglyMeasurable f μ
hf : 0 ≤ᶠ[ae μ] f
hg : 0 ≤ᶠ[ae μ] g
h_int : Integrable (f + g) μ
a : α
haf : 0 a ≤ f a
hag : 0 a ≤ g a
⊢ ‖f a‖ ≤ (f + g) a
state_after: no goals
Theorem: Profinite.NobelingProof.Products.lt_iff_lex_lt
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: cases l
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l m : Products I
⊢ l < m ↔ List.Lex (fun x x_1 => x < x_1) ↑l ↑m
state_after: case mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
m : Products I
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝, property✝⟩ < m ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝, property✝⟩ ↑m

tactic: cases m
state_before: case mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
m : Products I
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝, property✝⟩ < m ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝, property✝⟩ ↑m
state_after: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝¹, property✝¹⟩ < ⟨val✝, property✝⟩ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩

tactic: rw [Subtype.mk_lt_mk]
state_before: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ ⟨val✝¹, property✝¹⟩ < ⟨val✝, property✝⟩ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩
state_after: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ val✝¹ < val✝ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩

tactic: exact Iff.rfl
state_before: case mk.mk
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
val✝¹ : List I
property✝¹ : List.Chain' (fun x x_1 => x > x_1) val✝¹
val✝ : List I
property✝ : List.Chain' (fun x x_1 => x > x_1) val✝
⊢ val✝¹ < val✝ ↔ List.Lex (fun x x_1 => x < x_1) ↑⟨val✝¹, property✝¹⟩ ↑⟨val✝, property✝⟩
state_after: no goals
Theorem: Set.Finite.subset_toFinset
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← Finset.coe_subset, Finite.coe_toFinset]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
a : α
hs : s✝.Finite
ht : t.Finite
s : Finset α
⊢ s ⊆ ht.toFinset ↔ ↑s ⊆ t
state_after: no goals
Theorem: Filter.Germ.isConstant_compTendsto
File: Mathlib/Order/Filter/Germ.lean

tactic: induction f using Quotient.inductionOn with | _ f => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ g✝ h : α → β
f : l.Germ β
lc : Filter γ
g : γ → α
hf : f.IsConstant
hg : Tendsto g lc l
⊢ (f.compTendsto g hg).IsConstant
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ g✝ h : α → β
lc : Filter γ
g : γ → α
hg : Tendsto g lc l
f : α → β
hf : IsConstant ⟦f⟧
⊢ (compTendsto ⟦f⟧ g hg).IsConstant

tactic: exact isConstant_comp_tendsto hf hg
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ g✝ h : α → β
lc : Filter γ
g : γ → α
hg : Tendsto g lc l
f : α → β
hf : IsConstant ⟦f⟧
⊢ (compTendsto ⟦f⟧ g hg).IsConstant
state_after: no goals
Theorem: Complex.ofReal_mem_slitPlane
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simp [mem_slitPlane_iff]
state_before: x : ℝ
⊢ ↑x ∈ slitPlane ↔ 0 < x
state_after: no goals
Theorem: List.getElem_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp_all
state_before: α : Type u
n : ℕ
f : Fin n → α
i : ℕ
h : i < (ofFn f).length
⊢ i < n
state_after: no goals

tactic: simp [ofFn, getElem_ofFn_go]
state_before: α : Type u
n : ℕ
f : Fin n → α
i : ℕ
h : i < (ofFn f).length
⊢ (ofFn f)[i] = f ⟨i, ⋯⟩
state_after: no goals
Theorem: IsScalarTower.of_algebraMap_smul
File: Mathlib/Algebra/Algebra/Tower.lean

tactic: rw [Algebra.smul_def, mul_smul, h]
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : MulAction A M
inst✝ : SMul R M
h : ∀ (r : R) (x : M), (algebraMap R A) r • x = r • x
r : R
a : A
x : M
⊢ (r • a) • x = r • a • x
state_after: no goals
Theorem: CategoryTheory.Quotient.induction
File: Mathlib/CategoryTheory/Quotient.lean

tactic: rintro ⟨x⟩ ⟨y⟩ ⟨f⟩
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
P : {a b : Quotient r} → (a ⟶ b) → Prop
h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)
⊢ ∀ {a b : Quotient r} (f : a ⟶ b), P f
state_after: case mk.mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
P : {a b : Quotient r} → (a ⟶ b) → Prop
h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)
x y : C
f✝ : { as := x } ⟶ { as := y }
f : { as := x }.as ⟶ { as := y }.as
⊢ P (Quot.mk (CompClosure r) f)

tactic: exact h f
state_before: case mk.mk.mk
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
P : {a b : Quotient r} → (a ⟶ b) → Prop
h : ∀ {x y : C} (f : x ⟶ y), P ((functor r).map f)
x y : C
f✝ : { as := x } ⟶ { as := y }
f : { as := x }.as ⟶ { as := y }.as
⊢ P (Quot.mk (CompClosure r) f)
state_after: no goals