ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.Kernel.IsMarkovKernel.comapRight
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
⊢ IsMarkovKernel (κ.comapRight hf)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ ((κ.comapRight hf) a) Set.univ = 1
tactic: refine ⟨fun a => ⟨?_⟩⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ ((κ.comapRight hf) a) Set.univ = 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (f '' Set.univ) = 1
tactic: rw [comapRight_apply' κ hf a MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (f '' Set.univ) = 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (Set.range f) = 1
tactic: simp only [Set.image_univ, Subtype.range_coe_subtype, Set.setOf_mem_eq]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : Kernel α β
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (Set.range f) = 1
state_after: no goals
tactic: exact hκ a
Theorem: Ideal.mem_toCotangent_ker
File: Mathlib/RingTheory/Ideal/Cotangent.lean

Proof steps:
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : ↥I
⊢ x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ I ^ 2
state_after: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : ↥I
⊢ x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent)
tactic: rw [← I.map_toCotangent_ker]
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
x : ↥I
⊢ x ∈ LinearMap.ker I.toCotangent ↔ ↑x ∈ Submodule.map (Submodule.subtype I) (LinearMap.ker I.toCotangent)
state_after: no goals
tactic: simp
Theorem: Polynomial.card_roots'
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
⊢ Multiset.card p.roots ≤ p.natDegree
state_after: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
hp0 : p = 0
⊢ Multiset.card p.roots ≤ p.natDegree

case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
hp0 : ¬p = 0
⊢ Multiset.card p.roots ≤ p.natDegree
tactic: by_cases hp0 : p = 0
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
hp0 : ¬p = 0
⊢ Multiset.card p.roots ≤ p.natDegree
state_after: no goals
tactic: exact WithBot.coe_le_coe.1 (le_trans (card_roots hp0) (le_of_eq <| degree_eq_natDegree hp0))
Theorem: LinearMap.toMatrix₂_apply
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : Module R M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R M₂
inst✝⁵ : AddCommMonoid N₂
inst✝⁴ : Module R N₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : M₁ →ₗ[R] M₂ →ₗ[R] N₂
i : n
j : m
⊢ (toMatrix₂ b₁ b₂) B i j = (B (b₁ i)) (b₂ j)
state_after: no goals
tactic: simp only [toMatrix₂, LinearEquiv.trans_apply, toMatrix₂'_apply, LinearEquiv.arrowCongr_apply,
    Basis.equivFun_symm_apply, stdBasis_apply', ite_smul, one_smul, zero_smul, sum_ite_eq, mem_univ,
    ↓reduceIte, LinearEquiv.refl_apply]
Theorem: Odd.pow_nonpos_iff
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd n
⊢ a ^ n ≤ 0 ↔ a ≤ 0
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd n
⊢ n ≠ 0
tactic: rw [le_iff_lt_or_eq, le_iff_lt_or_eq, hn.pow_neg_iff, pow_eq_zero_iff]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m n : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd n
⊢ n ≠ 0
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd 0
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : LinearOrderedSemiring R
a b : R
m : ℕ
inst✝ : ExistsAddOfLE R
hn : Odd 0
⊢ False
state_after: no goals
tactic: simp [Odd, eq_comm (a := 0)] at hn
Theorem: deriv.comp_of_eq
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : DifferentiableAt 𝕜' h₂ y
hh : DifferentiableAt 𝕜 h x
hy : y = h x
⊢ deriv (h₂ ∘ h) x = deriv h₂ (h x) * deriv h x
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : DifferentiableAt 𝕜' h₂ (h x)
hh : DifferentiableAt 𝕜 h x
hy : y = h x
⊢ deriv (h₂ ∘ h) x = deriv h₂ (h x) * deriv h x
tactic: rw [hy] at hh₂
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
hh₂ : DifferentiableAt 𝕜' h₂ (h x)
hh : DifferentiableAt 𝕜 h x
hy : y = h x
⊢ deriv (h₂ ∘ h) x = deriv h₂ (h x) * deriv h x
state_after: no goals
tactic: exact deriv.comp x hh₂ hh
Theorem: List.drop_take_succ_eq_cons_nthLe
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L : List α
i : ℕ
hi : i < L.length
⊢ drop i (take (i + 1) L) = [L.nthLe i hi]
state_after: case nil
α : Type u_1
β : Type u_2
i : ℕ
hi : i < [].length
⊢ drop i (take (i + 1) []) = [[].nthLe i hi]

case cons
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i < (head :: tail).length
⊢ drop i (take (i + 1) (head :: tail)) = [(head :: tail).nthLe i hi]
tactic: induction' L with head tail generalizing i
state_before: case cons
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i < (head :: tail).length
⊢ drop i (take (i + 1) (head :: tail)) = [(head :: tail).nthLe i hi]
state_after: case cons.zero
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
hi : 0 < (head :: tail).length
⊢ drop 0 (take (0 + 1) (head :: tail)) = [(head :: tail).nthLe 0 hi]

case cons.succ
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i + 1 < (head :: tail).length
⊢ drop (i + 1) (take (i + 1 + 1) (head :: tail)) = [(head :: tail).nthLe (i + 1) hi]
tactic: cases' i with i hi
state_before: case cons.succ
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i + 1 < (head :: tail).length
⊢ drop (i + 1) (take (i + 1 + 1) (head :: tail)) = [(head :: tail).nthLe (i + 1) hi]
state_after: case cons.succ
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i + 1 < (head :: tail).length
this : i < tail.length
⊢ drop (i + 1) (take (i + 1 + 1) (head :: tail)) = [(head :: tail).nthLe (i + 1) hi]
tactic: have : i < tail.length := by simpa using hi
state_before: case cons.succ
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i + 1 < (head :: tail).length
this : i < tail.length
⊢ drop (i + 1) (take (i + 1 + 1) (head :: tail)) = [(head :: tail).nthLe (i + 1) hi]
state_after: case cons.succ
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i + 1 < (head :: tail).length
this : i < tail.length
⊢ tail.nthLe i ⋯ = (head :: tail).nthLe (i + 1) hi
tactic: simp [*]
state_before: case cons.succ
α : Type u_1
β : Type u_2
head : α
tail : List α
tail_ih✝ : ∀ {i : ℕ} (hi : i < tail.length), drop i (take (i + 1) tail) = [tail.nthLe i hi]
i : ℕ
hi : i + 1 < (head :: tail).length
this : i < tail.length
⊢ tail.nthLe i ⋯ = (head :: tail).nthLe (i + 1) hi
state_after: no goals
tactic: rfl
Theorem: Finset.Ico_add_Icc_subset
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : PartialOrder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
inst✝ : LocallyFiniteOrder α
a b c d : α
⊢ ↑(Ico a b * Icc c d) ⊆ ↑(Ico (a * c) (b * d))
state_after: no goals
tactic: simpa using Set.Ico_mul_Icc_subset' _ _ _ _
Theorem: NumberField.mixedEmbedding.minkowskiBound_lt_top
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
⊢ minkowskiBound K I < ⊤
state_after: case refine_1
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
⊢ volume (fundamentalDomain (fractionalIdealLatticeBasis K I)) ≠ ⊤

case refine_2
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
I : (FractionalIdeal (𝓞 K)⁰ K)ˣ
⊢ 2 ^ finrank ℝ (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) ≠ ⊤
tactic: refine ENNReal.mul_lt_top ?_ ?_
Theorem: Pi.isAtom_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι✝ : Sort u_1
α : Type u_2
β : Type u_3
ι : Type u_4
π : ι → Type u
f : (i : ι) → π i
inst✝¹ : (i : ι) → PartialOrder (π i)
inst✝ : (i : ι) → OrderBot (π i)
⊢ IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ (j : ι), j ≠ i → f j = ⊥
state_after: no goals
tactic: classical
  constructor
  case mpr =>
    rintro ⟨i, ⟨hfi, hlt⟩, hbot⟩
    refine ⟨fun h => hfi ((Pi.eq_bot_iff.1 h) _), fun g hgf => Pi.eq_bot_iff.2 fun j => ?_⟩
    have ⟨hgf, k, hgfk⟩ := Pi.lt_def.1 hgf
    obtain rfl : i = k := of_not_not fun hki => by rw [hbot _ (Ne.symm hki)] at hgfk; simp at hgfk
    if hij : j = i then subst hij; refine hlt _ hgfk else
    exact eq_bot_iff.2 <| le_trans (hgf _) (eq_bot_iff.1 (hbot _ hij))
  case mp =>
    rintro ⟨hbot, h⟩
    have ⟨i, hbot⟩ : ∃ i, f i ≠ ⊥ := by rw [ne_eq, Pi.eq_bot_iff, not_forall] at hbot; exact hbot
    refine ⟨i, ⟨hbot, ?c⟩, ?d⟩
    case c =>
      intro b hb
      have := h (Function.update ⊥ i b)
      simp only [lt_def, le_def, Pi.eq_bot_iff, and_imp, forall_exists_index] at this
      simpa using this
        (fun j => by by_cases h : j = i; { subst h; simpa using le_of_lt hb }; simp [h])
        i (by simpa using hb) i
    case d =>
      intro j hj
      have := h (Function.update ⊥ j (f j))
      simp only [lt_def, le_def, Pi.eq_bot_iff, and_imp, forall_exists_index] at this
      simpa using this (fun k => by by_cases h : k = j; { subst h; simp }; simp [h]) i
        (by rwa [Function.update_noteq (Ne.symm hj), bot_apply, bot_lt_iff_ne_bot]) j
Theorem: ContinuousLinearEquiv.comp_fderiv
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

Proof steps:
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
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
⊢ fderiv 𝕜 (⇑iso ∘ f) x = (↑iso).comp (fderiv 𝕜 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
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
⊢ fderivWithin 𝕜 (⇑iso ∘ f) univ x = (↑iso).comp (fderivWithin 𝕜 f univ x)
tactic: rw [← fderivWithin_univ, ← fderivWithin_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
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
⊢ fderivWithin 𝕜 (⇑iso ∘ f) univ x = (↑iso).comp (fderivWithin 𝕜 f univ x)
state_after: no goals
tactic: exact iso.comp_fderivWithin uniqueDiffWithinAt_univ
Theorem: SimpleGraph.Subgraph.connected_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
⊢ H.Connected ↔ H.Preconnected ∧ H.verts.Nonempty
state_after: no goals
tactic: rw [H.connected_iff', connected_iff, H.preconnected_iff, Set.nonempty_coe_sort]
Theorem: Con.lift_unique
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y : M
f : M →* P
H : c ≤ ker f
g : c.Quotient →* P
Hg : g.comp c.mk' = f
x : M
⊢ g ↑x = (c.lift f H) ↑x
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y : M
g : c.Quotient →* P
x : M
H : c ≤ ker (g.comp c.mk')
⊢ g ↑x = (c.lift (g.comp c.mk') H) ↑x
tactic: subst f
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
c : Con M
x✝ y : M
g : c.Quotient →* P
x : M
H : c ≤ ker (g.comp c.mk')
⊢ g ↑x = (c.lift (g.comp c.mk') H) ↑x
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.end_componentCompl_infinite
File: Mathlib/Combinatorics/SimpleGraph/Ends/Properties.lean

Proof steps:
state_before: V : Type
G : SimpleGraph V
e : ↑G.end
K : (Finset V)ᵒᵖ
⊢ (ComponentCompl.supp (↑e K)).Infinite
state_after: V : Type
G : SimpleGraph V
e : ↑G.end
K : (Finset V)ᵒᵖ
L : Finset V
h : Opposite.unop K ⊆ L
⊢ ∃ D, ComponentCompl.hom h D = ↑e K
tactic: refine (e.val K).infinite_iff_in_all_ranges.mpr (fun L h => ?_)
state_before: V : Type
G : SimpleGraph V
e : ↑G.end
K : (Finset V)ᵒᵖ
L : Finset V
h : Opposite.unop K ⊆ L
⊢ ∃ D, ComponentCompl.hom h D = ↑e K
state_after: V : Type
G : SimpleGraph V
e : ↑G.end
K : (Finset V)ᵒᵖ
L : Finset V
h : Opposite.unop K ⊆ Opposite.unop (Opposite.op L)
⊢ ∃ D, ComponentCompl.hom h D = ↑e K
tactic: change Opposite.unop K ⊆ Opposite.unop (Opposite.op L) at h
state_before: V : Type
G : SimpleGraph V
e : ↑G.end
K : (Finset V)ᵒᵖ
L : Finset V
h : Opposite.unop K ⊆ Opposite.unop (Opposite.op L)
⊢ ∃ D, ComponentCompl.hom h D = ↑e K
state_after: no goals
tactic: exact ⟨e.val (Opposite.op L), (e.prop (CategoryTheory.opHomOfLE h))⟩
Theorem: Set.enumerateCountable_mem
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
h : s.Countable
default : α
h_mem : default ∈ s
n : ℕ
⊢ enumerateCountable h default n ∈ s
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
h : s.Countable
default : α
h_mem : default ∈ s
n : ℕ
⊢ enumerateCountable h default n ∈ range (enumerateCountable h default)
tactic: conv_rhs => rw [← range_enumerateCountable_of_mem h h_mem]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
h : s.Countable
default : α
h_mem : default ∈ s
n : ℕ
⊢ enumerateCountable h default n ∈ range (enumerateCountable h default)
state_after: no goals
tactic: exact mem_range_self n
Theorem: finprod_mem_eq_one_of_forall_eq_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Set α
h : ∀ x ∈ s, f x = 1
⊢ ∏ᶠ (i : α) (_ : i ∈ s), f i = 1
state_after: no goals
tactic: simp (config := { contextual := true }) [h]
Theorem: WithLp.prod_edist_self
File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp p (α × β)
⊢ edist f f = 0
state_after: case inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp 0 (α × β)
⊢ edist f f = 0

case inr.inl
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp ⊤ (α × β)
⊢ edist f f = 0

case inr.inr
p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : WithLp p (α × β)
h : 0 < p.toReal
⊢ edist f f = 0
tactic: rcases p.trichotomy with (rfl | rfl | h)
Theorem: Rat.mkRat_add_mkRat
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
⊢ mkRat n₁ d₁ + mkRat n₂ d₂ = mkRat (n₁ * ↑d₂ + n₂ * ↑d₁) (d₁ * d₂)
state_after: no goals
tactic: rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_add_normalize, normalize_eq_mkRat]
Theorem: ProbabilityTheory.iCondIndepSet_iff
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
s : ι → Set Ω
hs : ∀ (i : ι), MeasurableSet (s i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndepSet m' hm' s μ ↔
    ∀ (S : Finset ι), μ[(⋂ i ∈ S, s i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ S, μ[(s i).indicator fun ω => 1|m']
state_after: no goals
tactic: rw [iCondIndepSet_iff_iCondIndepSets_singleton _ _ _ hs, iCondIndepSets_singleton_iff _ _ _ hs]
Theorem: Set.Finite.surjOn_iff_bijOn_of_mapsTo
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
⊢ SurjOn f s s ↔ BijOn f s s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
⊢ InjOn f s
tactic: refine ⟨fun h ↦ ⟨hm, ?_, h⟩, BijOn.surjOn⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
⊢ InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
this : Finite ↑s
⊢ InjOn f s
tactic: have : Finite s := finite_coe_iff.mpr hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
f : α → α
hs : s.Finite
hm : MapsTo f s s
h : SurjOn f s s
this : Finite ↑s
⊢ InjOn f s
state_after: no goals
tactic: exact hm.restrict_inj.mp (Finite.injective_iff_surjective.mpr <| hm.restrict_surjective_iff.mpr h)
Theorem: CategoryTheory.Monad.ofMon_μ
File: Mathlib/CategoryTheory/Monad/EquivMon.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ M.one.app (M.X.obj X) ≫ M.mul.app X = 𝟙 ((𝟭 C).obj (M.X.obj X))
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.rightUnitor M.X).hom.app X = 𝟙 ((𝟭 C).obj (M.X.obj X))
tactic: erw [← whiskerLeft_app, ← NatTrans.comp_app, M.mul_one]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.rightUnitor M.X).hom.app X = 𝟙 ((𝟭 C).obj (M.X.obj X))
state_after: no goals
tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ M.X.map (M.one.app X) ≫ M.mul.app X = 𝟙 (M.X.obj ((𝟭 C).obj X))
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.leftUnitor M.X).hom.app X = 𝟙 (M.X.obj ((𝟭 C).obj X))
tactic: erw [← whiskerRight_app, ← NatTrans.comp_app, M.one_mul]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (MonoidalCategory.leftUnitor M.X).hom.app X = 𝟙 (M.X.obj ((𝟭 C).obj X))
state_after: no goals
tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ M.X.map (M.mul.app X) ≫ M.mul.app X = M.mul.app (M.X.obj X) ≫ M.mul.app X
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (whiskerRight M.mul M.X ≫ M.mul).app X = (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
tactic: rw [← whiskerLeft_app, ← whiskerRight_app, ← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ (whiskerRight M.mul M.X ≫ M.mul).app X = (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
state_after: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ ((MonoidalCategory.associator M.X M.X M.X).hom ≫ MonoidalCategory.whiskerLeft M.X M.mul ≫ M.mul).app X =
    (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
tactic: erw [M.mul_assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Mon_ (C ⥤ C)
X : C
⊢ ((MonoidalCategory.associator M.X M.X M.X).hom ≫ MonoidalCategory.whiskerLeft M.X M.mul ≫ M.mul).app X =
    (whiskerLeft M.X M.mul).app X ≫ M.mul.app X
state_after: no goals
tactic: simp