ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.PartiallyWellOrderedOn.exists_min_bad_of_exists_bad
File: Mathlib/Order/WellFoundedSet.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r✝ r : α → α → Prop
rk : α → ℕ
s : Set α
⊢ (∃ f, IsBadSeq r s f) → ∃ f, IsBadSeq r s f ∧ ∀ (n : ℕ), IsMinBadSeq r rk s n f
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r✝ r : α → α → Prop
rk : α → ℕ
s : Set α
f0 : ℕ → α
hf0 : IsBadSeq r s f0
⊢ ∃ f, IsBadSeq r s f ∧ ∀ (n : ℕ), IsMinBadSeq r rk s n f
tactic: rintro ⟨f0, hf0 : IsBadSeq r s f0⟩
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r✝ r : α → α → Prop
rk : α → ℕ
s : Set α
f0 : ℕ → α
hf0 : IsBadSeq r s f0
fs : (n : ℕ) → { f // IsBadSeq r s f ∧ IsMinBadSeq r rk s n f } :=
  fun t =>
    Nat.rec ⟨↑(minBadSeqOfBadSeq r rk s 0 f0 hf0), ⋯⟩ (fun n fn => ⟨↑(minBadSeqOfBadSeq r rk s (n + 1) ↑fn ⋯), ⋯⟩) t
h : ∀ (m n : ℕ), m ≤ n → ↑(fs m) m = ↑(fs n) m
⊢ ∃ f, IsBadSeq r s f ∧ ∀ (n : ℕ), IsMinBadSeq r rk s n f
state_after: case intro.refine_1
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r✝ r : α → α → Prop
rk : α → ℕ
s : Set α
f0 : ℕ → α
hf0 : IsBadSeq r s f0
fs : (n : ℕ) → { f // IsBadSeq r s f ∧ IsMinBadSeq r rk s n f } :=
  fun t =>
    Nat.rec ⟨↑(minBadSeqOfBadSeq r rk s 0 f0 hf0), ⋯⟩ (fun n fn => ⟨↑(minBadSeqOfBadSeq r rk s (n + 1) ↑fn ⋯), ⋯⟩) t
h : ∀ (m n : ℕ), m ≤ n → ↑(fs m) m = ↑(fs n) m
m n : ℕ
mn : m < n
⊢ ¬r ((fun n => ↑(fs n) n) m) ((fun n => ↑(fs n) n) n)

case intro.refine_2
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
r✝ r : α → α → Prop
rk : α → ℕ
s : Set α
f0 : ℕ → α
hf0 : IsBadSeq r s f0
fs : (n : ℕ) → { f // IsBadSeq r s f ∧ IsMinBadSeq r rk s n f } :=
  fun t =>
    Nat.rec ⟨↑(minBadSeqOfBadSeq r rk s 0 f0 hf0), ⋯⟩ (fun n fn => ⟨↑(minBadSeqOfBadSeq r rk s (n + 1) ↑fn ⋯), ⋯⟩) t
h : ∀ (m n : ℕ), m ≤ n → ↑(fs m) m = ↑(fs n) m
n : ℕ
g : ℕ → α
hg1 : ∀ m < n, (fun n => ↑(fs n) n) m = g m
hg2 : rk (g n) < rk ((fun n => ↑(fs n) n) n)
⊢ ¬IsBadSeq r s g
tactic: refine ⟨fun n => (fs n).1 n, ⟨fun n => (fs n).2.1.1 n, fun m n mn => ?_⟩, fun n g hg1 hg2 => ?_⟩
Theorem: infClosure_singleton
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
s t : Set α
a b : α
⊢ infClosure {a} = {a}
state_after: no goals
tactic: simp
Theorem: AddConstMap.coe_smul
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
K : Type u_3
inst✝² : Add G
inst✝¹ : AddZeroClass H
a : G
b : H
inst✝ : DistribSMul K H
c : K
f : G →+c[a, b] H
x : G
⊢ (c • ⇑f) (x + a) = (c • ⇑f) x + c • b
state_after: no goals
tactic: simp [smul_add]
Theorem: Profinite.pullback.hom_ext
File: Mathlib/Topology/Category/Profinite/Limits.lean

Proof steps:
state_before: X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
hfst : a ≫ fst f g = b ≫ fst f g
hsnd : a ≫ snd f g = b ≫ snd f g
⊢ a = b
state_after: case w
X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
hfst : a ≫ fst f g = b ≫ fst f g
hsnd : a ≫ snd f g = b ≫ snd f g
z : (forget Profinite).obj Z
⊢ a z = b z
tactic: ext z
state_before: case w
X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
z : (forget Profinite).obj Z
hfst : (a ≫ fst f g) z = (b ≫ fst f g) z
hsnd : (a ≫ snd f g) z = (b ≫ snd f g) z
⊢ a z = b z
state_after: case w.a
X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
z : (forget Profinite).obj Z
hfst : (a ≫ fst f g) z = (b ≫ fst f g) z
hsnd : (a ≫ snd f g) z = (b ≫ snd f g) z
⊢ ↑(a z) = ↑(b z)
tactic: apply Subtype.ext
state_before: case w.a
X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
z : (forget Profinite).obj Z
hfst : (a ≫ fst f g) z = (b ≫ fst f g) z
hsnd : (a ≫ snd f g) z = (b ≫ snd f g) z
⊢ ↑(a z) = ↑(b z)
state_after: case w.a.a
X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
z : (forget Profinite).obj Z
hfst : (a ≫ fst f g) z = (b ≫ fst f g) z
hsnd : (a ≫ snd f g) z = (b ≫ snd f g) z
⊢ (↑(a z)).1 = (↑(b z)).1

case w.a.a
X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
Z : Profinite
a b : Z ⟶ pullback f g
z : (forget Profinite).obj Z
hfst : (a ≫ fst f g) z = (b ≫ fst f g) z
hsnd : (a ≫ snd f g) z = (b ≫ snd f g) z
⊢ (↑(a z)).2 = (↑(b z)).2
tactic: apply Prod.ext
Theorem: toIcoMod_sub_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp (a - m • p) b = toIcoMod hp a b - m • p
state_after: no goals
tactic: simp_rw [sub_eq_add_neg, ← neg_smul, toIcoMod_add_zsmul']
Theorem: Polynomial.Monic.degree_le_zero_iff_eq_one
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
⊢ p.degree ≤ 0 ↔ p = 1
state_after: no goals
tactic: rw [← hp.natDegree_eq_zero_iff_eq_one, natDegree_eq_zero_iff_degree_le_zero]
Theorem: HasStrictDerivAt.finset_prod
File: Mathlib/Analysis/Calculus/Deriv/Mul.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
G : Type u_1
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
f✝ f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
ι : Type u_2
inst✝² : DecidableEq ι
𝔸' : Type u_3
inst✝¹ : NormedCommRing 𝔸'
inst✝ : NormedAlgebra 𝕜 𝔸'
u : Finset ι
f : ι → 𝕜 → 𝔸'
f' : ι → 𝔸'
hf : ∀ i ∈ u, HasStrictDerivAt (f i) (f' i) x
⊢ HasStrictDerivAt (fun x => ∏ i ∈ u, f i x) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) x
state_after: no goals
tactic: simpa [ContinuousLinearMap.sum_apply, ContinuousLinearMap.smul_apply] using
    (HasStrictFDerivAt.finset_prod (fun i hi ↦ (hf i hi).hasStrictFDerivAt)).hasStrictDerivAt
Theorem: MeasureTheory.lintegral_eq_lintegral_meas_lt
File: Mathlib/MeasureTheory/Integral/Layercake.lean

Proof steps:
state_before: α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
⊢ ∫⁻ (ω : α), ENNReal.ofReal (f ω) ∂μ = ∫⁻ (t : ℝ) in Ioi 0, μ {a | t < f a}
state_after: α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
⊢ ∫⁻ (t : ℝ) in Ioi 0, μ {a | t ≤ f a} = ∫⁻ (t : ℝ) in Ioi 0, μ {a | t < f a}
tactic: rw [lintegral_eq_lintegral_meas_le μ f_nn f_mble]
state_before: α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
⊢ ∫⁻ (t : ℝ) in Ioi 0, μ {a | t ≤ f a} = ∫⁻ (t : ℝ) in Ioi 0, μ {a | t < f a}
state_after: case h
α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
⊢ (fun a => μ {a_1 | a ≤ f a_1}) =ᶠ[ae (volume.restrict (Ioi 0))] fun a => μ {a_1 | a < f a_1}
tactic: apply lintegral_congr_ae
state_before: case h
α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
⊢ (fun a => μ {a_1 | a ≤ f a_1}) =ᶠ[ae (volume.restrict (Ioi 0))] fun a => μ {a_1 | a < f a_1}
state_after: case h
α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
t : ℝ
ht : μ {a | t ≤ f a} = μ {a | t < f a}
⊢ μ {a | t ≤ f a} = μ {a | t < f a}
tactic: filter_upwards [meas_le_ae_eq_meas_lt μ (volume.restrict (Ioi 0)) f]
    with t ht
state_before: case h
α : Type u_1
inst✝² : MeasurableSpace α
μ✝ : Measure α
β : Type u_2
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : Measure α
f_nn : 0 ≤ᶠ[ae μ] f
f_mble : AEMeasurable f μ
t : ℝ
ht : μ {a | t ≤ f a} = μ {a | t < f a}
⊢ μ {a | t ≤ f a} = μ {a | t < f a}
state_after: no goals
tactic: rw [ht]
Theorem: Matroid.basis_empty_iff
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
B I J X Y : Set α
e : α
M : Matroid α
h : I = ∅
⊢ M.Basis I ∅
state_after: no goals
tactic: (rw [h]; exact M.empty_indep.basis_self)
Theorem: Nat.Partition.ofComposition_surj
File: Mathlib/Combinatorics/Enumerative/Partition.lean

Proof steps:
state_before: n : ℕ
⊢ Function.Surjective (ofComposition n)
state_after: case mk
n : ℕ
b : Multiset ℕ
hb₁ : ∀ {i : ℕ}, i ∈ b → 0 < i
hb₂ : b.sum = n
⊢ ∃ a, ofComposition n a = { parts := b, parts_pos := hb₁, parts_sum := hb₂ }
tactic: rintro ⟨b, hb₁, hb₂⟩
state_before: case mk
n : ℕ
b : Multiset ℕ
hb₁ : ∀ {i : ℕ}, i ∈ b → 0 < i
hb₂ : b.sum = n
⊢ ∃ a, ofComposition n a = { parts := b, parts_pos := hb₁, parts_sum := hb₂ }
state_after: case mk.h
n : ℕ
b : List ℕ
hb₁ : ∀ {i : ℕ}, i ∈ ⟦b⟧ → 0 < i
hb₂ : sum ⟦b⟧ = n
⊢ ∃ a, ofComposition n a = { parts := ⟦b⟧, parts_pos := hb₁, parts_sum := hb₂ }
tactic: induction b using Quotient.inductionOn with | _ b => ?_
state_before: case mk.h
n : ℕ
b : List ℕ
hb₁ : ∀ {i : ℕ}, i ∈ ⟦b⟧ → 0 < i
hb₂ : sum ⟦b⟧ = n
⊢ ∃ a, ofComposition n a = { parts := ⟦b⟧, parts_pos := hb₁, parts_sum := hb₂ }
state_after: no goals
tactic: exact ⟨⟨b, hb₁, by simpa using hb₂⟩, Partition.ext _ _ rfl⟩
Theorem: AddSubmonoid.LocalizationMap.lift_add_right
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
z : N
⊢ (f.lift hg) z * g ↑(f.sec z).2 = g (f.sec z).1
state_after: no goals
tactic: erw [mul_assoc, IsUnit.liftRight_inv_mul, mul_one]
Theorem: BoxIntegral.integralSum_smul
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
c : ℝ
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π : TaggedPrepartition I
⊢ integralSum (c • f) vol π = c • integralSum f vol π
state_after: no goals
tactic: simp only [integralSum, Finset.smul_sum, Pi.smul_apply, ContinuousLinearMap.map_smul]
Theorem: CauSeq.inf_eq_left
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≤ b
⊢ a ⊓ b ≈ a
state_after: no goals
tactic: simpa only [CauSeq.inf_comm] using CauSeq.inf_eq_right h
Theorem: Option.pmap_eq_map
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p✝ : α → Prop
f✝ : (a : α) → p✝ a → β
x✝ : Option α
p : α → Prop
f : α → β
x : Option α
H : ∀ (a : α), a ∈ x → p a
⊢ pmap (fun a x => f a) x H = Option.map f x
state_after: no goals
tactic: cases x <;> simp only [map_none', map_some', pmap]
Theorem: MeasureTheory.AEStronglyMeasurable.mul_iff_right
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
f g : α → β
inst✝¹ : CommGroup β
inst✝ : TopologicalGroup β
hf : AEStronglyMeasurable f μ
h : AEStronglyMeasurable (f * g) μ
⊢ g = f * g * f⁻¹
state_after: no goals
tactic: simp only [mul_inv_cancel_comm]
Theorem: bernoulliFun_endpoints_eq_of_ne_one
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
hk : k ≠ 1
⊢ bernoulliFun k 1 = bernoulliFun k 0
state_after: no goals
tactic: rw [bernoulliFun_eval_zero, bernoulliFun, Polynomial.eval_one_map, Polynomial.bernoulli_eval_one,
    bernoulli_eq_bernoulli'_of_ne_one hk, eq_ratCast]
Theorem: continuous_from_compactlyGenerated
File: Mathlib/Topology/Category/CompactlyGenerated.lean

Proof steps:
state_before: X : Type w
inst✝ : TopologicalSpace X
Y : Type u_1
t : TopologicalSpace Y
f : X → Y
h : ∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g)
⊢ Continuous f
state_after: X : Type w
inst✝ : TopologicalSpace X
Y : Type u_1
t : TopologicalSpace Y
f : X → Y
h : ∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g)
⊢ Continuous
    (f ∘ fun x =>
      match x with
      | ⟨⟨fst, i⟩, s⟩ => i s)
tactic: rw [continuous_coinduced_dom]
state_before: X : Type w
inst✝ : TopologicalSpace X
Y : Type u_1
t : TopologicalSpace Y
f : X → Y
h : ∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g)
⊢ Continuous
    (f ∘ fun x =>
      match x with
      | ⟨⟨fst, i⟩, s⟩ => i s)
state_after: no goals
tactic: continuity
Theorem: Submodule.snd_map_snd
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ map (LinearMap.snd R M M₂) (snd R M M₂) = ⊤
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ⊤ ≤ map (LinearMap.snd R M M₂) (snd R M M₂)
tactic: rw [eq_top_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ⊤ ≤ map (LinearMap.snd R M M₂) (snd R M M₂)
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (LinearMap.snd R M M₂) (snd R M M₂)
tactic: rintro x -
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M₂
⊢ x ∈ map (LinearMap.snd R M M₂) (snd R M M₂)
state_after: no goals
tactic: simp only [snd, comap_bot, mem_map, mem_ker, snd_apply, fst_apply,
    Prod.exists, exists_eq_right, exists_eq]
Theorem: List.dvd_prod
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
⊢ a ∣ l.prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
s t : List M
h : l = s ++ a :: t
⊢ a ∣ l.prod
tactic: let ⟨s, t, h⟩ := append_of_mem ha
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
s t : List M
h : l = s ++ a :: t
⊢ a ∣ l.prod
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
s t : List M
h : l = s ++ a :: t
⊢ a ∣ a * (s.prod * t.prod)
tactic: rw [h, prod_append, prod_cons, mul_left_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommMonoid M
a : M
l : List M
ha : a ∈ l
s t : List M
h : l = s ++ a :: t
⊢ a ∣ a * (s.prod * t.prod)
state_after: no goals
tactic: exact dvd_mul_right _ _
Theorem: Set.list_prod_mem_list_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : List ι
f : ι → Set α
g : ι → α
hg : ∀ i ∈ t, g i ∈ f i
⊢ (List.map g t).prod ∈ (List.map f t).prod
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
hg : ∀ i ∈ [], g i ∈ f i
⊢ (List.map g []).prod ∈ (List.map f []).prod

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
h : ι
tl : List ι
ih : (∀ i ∈ tl, g i ∈ f i) → (List.map g tl).prod ∈ (List.map f tl).prod
hg : ∀ i ∈ h :: tl, g i ∈ f i
⊢ (List.map g (h :: tl)).prod ∈ (List.map f (h :: tl)).prod
tactic: induction' t with h tl ih
Theorem: Ordinal.log_le_self
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b x : Ordinal.{u_1}
hx : x = 0
⊢ log b x ≤ x
state_after: no goals
tactic: simp only [hx, log_zero_right, Ordinal.zero_le]
state_before: b x : Ordinal.{u_1}
hx : ¬x = 0
hb : ¬1 < b
⊢ log b x ≤ x
state_after: no goals
tactic: simp only [log_of_not_one_lt_left hb, Ordinal.zero_le]
Theorem: genericPoint_spec
File: Mathlib/Topology/Sober.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : QuasiSober α
inst✝ : IrreducibleSpace α
⊢ IsGenericPoint (genericPoint α) ⊤
state_after: no goals
tactic: simpa using (IrreducibleSpace.isIrreducible_univ α).genericPoint_spec
Theorem: WeierstrassCurve.Affine.Point.map_map
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R✝ : Type u
inst✝²³ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝²² : CommRing R
W : Affine R
S : Type s
inst✝²¹ : CommRing S
inst✝²⁰ : Algebra R S
A : Type u
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Algebra R A
inst✝¹⁷ : Algebra S A
inst✝¹⁶ : IsScalarTower R S A
B : Type v
inst✝¹⁵ : CommRing B
inst✝¹⁴ : Algebra R B
inst✝¹³ : Algebra S B
inst✝¹² : IsScalarTower R S B
f✝ : A →ₐ[S] B
F : Type u
inst✝¹¹ : Field F
inst✝¹⁰ : Algebra R F
inst✝⁹ : Algebra S F
inst✝⁸ : IsScalarTower R S F
K : Type v
inst✝⁷ : Field K
inst✝⁶ : Algebra R K
inst✝⁵ : Algebra S K
inst✝⁴ : IsScalarTower R S K
f : F →ₐ[S] K
L : Type w
inst✝³ : Field L
inst✝² : Algebra R L
inst✝¹ : Algebra S L
inst✝ : IsScalarTower R S L
g : K →ₐ[S] L
P : W⟮F⟯
⊢ (map W g) ((map W f) P) = (map W (g.comp f)) P
state_after: no goals
tactic: cases P <;> rfl
Theorem: exists_ne_zero_of_finsum_mem_ne_zero
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 g : α → M
a b : α
s t : Set α
h : ∏ᶠ (i : α) (_ : i ∈ s), f i ≠ 1
⊢ ∃ x ∈ s, f x ≠ 1
state_after: α : 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 g : α → M
a b : α
s t : Set α
h : ∏ᶠ (i : α) (_ : i ∈ s), f i ≠ 1
h' : ∀ x ∈ s, f x = 1
⊢ False
tactic: by_contra! h'
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 g : α → M
a b : α
s t : Set α
h : ∏ᶠ (i : α) (_ : i ∈ s), f i ≠ 1
h' : ∀ x ∈ s, f x = 1
⊢ False
state_after: no goals
tactic: exact h (finprod_mem_of_eqOn_one h')
Theorem: isConformalMap_iff_is_complex_or_conj_linear
File: Mathlib/Analysis/Complex/Conformal.lean

Proof steps:
state_before: f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ IsConformalMap g ↔ ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = g.comp ↑conjCLE) ∧ g ≠ 0
state_after: case mp
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ IsConformalMap g → ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = g.comp ↑conjCLE) ∧ g ≠ 0

case mpr
f : ℂ → ℂ
z : ℂ
g : ℂ →L[ℝ] ℂ
⊢ ((∃ map, restrictScalars ℝ map = g) ∨ ∃ map, restrictScalars ℝ map = g.comp ↑conjCLE) ∧ g ≠ 0 → IsConformalMap g
tactic: constructor
Theorem: CategoryTheory.Comma.isoMk_inv_left
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.20583, u_1} A'
inst✝¹ : Category.{?u.20587, u_2} B'
inst✝ : Category.{?u.20591, u_3} T'
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
X Y : Comma L₁ R₁
l : X.left ≅ Y.left
r : X.right ≅ Y.right
h : autoParam (L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom) _auto✝
⊢ L₁.map l.inv ≫ X.hom = Y.hom ≫ R₁.map r.inv
state_after: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.20583, u_1} A'
inst✝¹ : Category.{?u.20587, u_2} B'
inst✝ : Category.{?u.20591, u_3} T'
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
X Y : Comma L₁ R₁
l : X.left ≅ Y.left
r : X.right ≅ Y.right
h : autoParam (L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom) _auto✝
⊢ X.hom = X.hom ≫ R₁.map (r.hom ≫ r.inv)
tactic: rw [← L₁.mapIso_inv l, Iso.inv_comp_eq, L₁.mapIso_hom, ← Category.assoc, h,
          Category.assoc, ← R₁.map_comp]
state_before: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.20583, u_1} A'
inst✝¹ : Category.{?u.20587, u_2} B'
inst✝ : Category.{?u.20591, u_3} T'
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
X Y : Comma L₁ R₁
l : X.left ≅ Y.left
r : X.right ≅ Y.right
h : autoParam (L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom) _auto✝
⊢ X.hom = X.hom ≫ R₁.map (r.hom ≫ r.inv)
state_after: no goals
tactic: simp
Theorem: ContextFreeGrammar.mem_language_iff
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
⊢ w ∈ g.language ↔ g.Derives [Symbol.nonterminal g.initial] (List.map Symbol.terminal w)
state_after: no goals
tactic: rfl