ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.coe_span_eq_self
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
⊢ ↑(span R ↑s) = ↑s
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
⊢ ↑(span R ↑s) ≤ ↑s
tactic: refine le_antisymm ?_ subset_span
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
⊢ ↑(span R ↑s) ≤ ↑s
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
s' : Submodule R M := { carrier := ↑s, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ }
⊢ ↑(span R ↑s) ≤ ↑s
tactic: let s' : Submodule R M :=
    { carrier := s
      add_mem' := add_mem
      zero_mem' := zero_mem _
      smul_mem' := SMulMemClass.smul_mem }
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
s' : Submodule R M := { carrier := ↑s, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ }
⊢ ↑(span R ↑s) ≤ ↑s
state_after: no goals
tactic: exact span_le (p := s') |>.mpr le_rfl
Theorem: Nat.dvd_gcd_mul_iff_dvd_mul
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: x n m : ℕ
x✝ : x ∣ n * m
y : ℕ
hy : n * m = x * y
⊢ x ∣ x.gcd n * m
state_after: x n m : ℕ
x✝ : x ∣ n * m
y : ℕ
hy : n * m = x * y
⊢ x ∣ x * m.gcd y
tactic: rw [← gcd_mul_right, hy, gcd_mul_left]
state_before: x n m : ℕ
x✝ : x ∣ n * m
y : ℕ
hy : n * m = x * y
⊢ x ∣ x * m.gcd y
state_after: no goals
tactic: exact dvd_mul_right x (gcd m y)
Theorem: MeasureTheory.weightedSMul_add_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
⊢ weightedSMul (μ + ν) s = weightedSMul μ s + weightedSMul ν s
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ (weightedSMul (μ + ν) s) x = (weightedSMul μ s + weightedSMul ν s) x
tactic: ext1 x
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ (weightedSMul (μ + ν) s) x = (weightedSMul μ s + weightedSMul ν s) x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ (weightedSMul (μ + ν) s) x = (⇑(weightedSMul μ s) + ⇑(weightedSMul ν s)) x
tactic: push_cast
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ (weightedSMul (μ + ν) s) x = (⇑(weightedSMul μ s) + ⇑(weightedSMul ν s)) x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ ((μ + ν) s).toReal • x = (μ s).toReal • x + (ν s).toReal • x
tactic: simp_rw [Pi.add_apply, weightedSMul_apply]
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ ((μ + ν) s).toReal • x = (μ s).toReal • x + (ν s).toReal • x
state_after: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ ((⇑μ + ⇑ν) s).toReal • x = (μ s).toReal • x + (ν s).toReal • x
tactic: push_cast
state_before: case h
α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
s : Set α
hμs : μ s ≠ ⊤
hνs : ν s ≠ ⊤
x : F
⊢ ((⇑μ + ⇑ν) s).toReal • x = (μ s).toReal • x + (ν s).toReal • x
state_after: no goals
tactic: rw [Pi.add_apply, ENNReal.toReal_add hμs hνs, add_smul]
Theorem: CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
K : Multifork I
⊢ ∀ (j : WalkingMulticospan I.fstTo I.sndTo),
    ((𝟭 (Multifork I)).obj K).π.app j =
      (Iso.refl ((𝟭 (Multifork I)).obj K).pt).hom ≫ ((I.toPiForkFunctor ⋙ I.ofPiForkFunctor).obj K).π.app j
state_after: no goals
tactic: rintro (_ | _) <;> simp [← Fork.app_one_eq_ι_comp_left]
Theorem: List.map_enumFrom_eq_zipWith
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
⊢ ∀ (l : List α) (n : ℕ) (f : ℕ → α → β),
    map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range l.length) l
state_after: α : Type u
β : Type v
l : List α
⊢ ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range l.length) l
tactic: intro l
state_before: α : Type u
β : Type v
l : List α
⊢ ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range l.length) l
state_after: α : Type u
β : Type v
l : List α
len : ℕ
e : l.length = len
⊢ ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range len) l
tactic: generalize e : l.length = len
state_before: α : Type u
β : Type v
l : List α
len : ℕ
e : l.length = len
⊢ ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range len) l
state_after: α : Type u
β : Type v
len : ℕ
⊢ ∀ (l : List α),
    l.length = len →
      ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range len) l
tactic: revert l
state_before: α : Type u
β : Type v
len : ℕ
⊢ ∀ (l : List α),
    l.length = len →
      ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range len) l
state_after: case zero
α : Type u
β : Type v
l : List α
e : l.length = 0
n : ℕ
f : ℕ → α → β
⊢ map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range 0) l

case succ
α : Type u
β : Type v
len : ℕ
ih :
  ∀ (l : List α),
    l.length = len →
      ∀ (n : ℕ) (f : ℕ → α → β), map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range len) l
l : List α
e : l.length = len + 1
n : ℕ
f : ℕ → α → β
⊢ map (uncurry f) (enumFrom n l) = zipWith (fun i => f (i + n)) (range (len + 1)) l
tactic: induction' len with len ih <;> intros l e n f
Theorem: Commute.div_left
File: Mathlib/Algebra/GroupWithZero/Commute.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c : G₀
hac : Commute a c
hbc : Commute b c
⊢ Commute (a / b) c
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c : G₀
hac : Commute a c
hbc : Commute b c
⊢ Commute (a * b⁻¹) c
tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c : G₀
hac : Commute a c
hbc : Commute b c
⊢ Commute (a * b⁻¹) c
state_after: no goals
tactic: exact hac.mul_left hbc.inv_left₀
Theorem: List.range'_1_concat
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: s n : Nat
⊢ range' s (n + 1) = range' s n ++ [s + n]
state_after: no goals
tactic: simp [range'_concat]
Theorem: Associates.count_self
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : Nontrivial α
inst✝ : DecidableEq (Associates α)
p : Associates α
hp : Irreducible p
⊢ p.count p.factors = 1
state_after: no goals
tactic: simp [factors_self hp, Associates.count_some hp]
Theorem: SimplicialObject.Split.cofan_inj_naturality_symm
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
S₁ S₂ : Split C
Φ : S₁ ⟶ S₂
Δ : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
⊢ (S₁.s.cofan Δ).inj A ≫ Φ.F.app Δ = Φ.f (unop A.fst).len ≫ (S₂.s.cofan Δ).inj A
state_after: no goals
tactic: erw [S₁.s.cofan_inj_eq, S₂.s.cofan_inj_eq, assoc, Φ.F.naturality, ← Φ.comm_assoc]
Theorem: Rack.left_cancel
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃ y = x ◃ y' ↔ y = y'
state_after: case mp
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃ y = x ◃ y' → y = y'

case mpr
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ y = y' → x ◃ y = x ◃ y'
tactic: constructor
state_before: case mpr
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ y = y' → x ◃ y = x ◃ y'
state_after: case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ y = x ◃ y
tactic: rintro rfl
state_before: case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ y = x ◃ y
state_after: no goals
tactic: rfl
Theorem: Nat.squarefree_two
File: Mathlib/Data/Nat/Squarefree.lean

Proof steps:
state_before: s : Finset ℕ
m n p : ℕ
⊢ Squarefree 2
state_after: no goals
tactic: rw [squarefree_iff_nodup_primeFactorsList] <;> simp
Theorem: Polynomial.prod_X_sub_C_nextCoeff
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s✝ : Finset ι
inst✝ : CommRing R
s : Finset ι
f : ι → R
⊢ (∏ i ∈ s, (X - C (f i))).nextCoeff = -∑ i ∈ s, f i
state_after: no goals
tactic: simpa using multiset_prod_X_sub_C_nextCoeff (s.1.map f)
Theorem: intervalIntegral.integral_deriv_comp_mul_deriv
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f✝¹ : ℝ → E
g'✝ g✝ φ : ℝ → ℝ
a b : ℝ
inst✝ : CompleteSpace E
f✝ f'✝ : ℝ → E
f f' g g' : ℝ → ℝ
hf : ∀ x ∈ [[a, b]], HasDerivAt f (f' x) x
hg : ∀ x ∈ [[a, b]], HasDerivAt g (g' (f x)) (f x)
hf' : ContinuousOn f' [[a, b]]
hg' : Continuous g'
⊢ ∫ (x : ℝ) in a..b, (g' ∘ f) x * f' x = (g ∘ f) b - (g ∘ f) a
state_after: no goals
tactic: simpa [mul_comm] using integral_deriv_comp_smul_deriv hf hg hf' hg'
Theorem: Real.borel_eq_generateFrom_Ici_rat
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
⊢ borel ℝ = generateFrom (⋃ a, {Ici ↑a})
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
⊢ generateFrom (range fun a => Iio ↑a) = generateFrom (range fun a => Ici ↑a)
tactic: rw [borel_eq_generateFrom_Iio_rat, iUnion_singleton_eq_range, iUnion_singleton_eq_range]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s t u : Set α
⊢ generateFrom (range fun a => Iio ↑a) = generateFrom (range fun a => Ici ↑a)
state_after: no goals
tactic: refine le_antisymm (generateFrom_le ?_) (generateFrom_le ?_) <;>
  rintro _ ⟨q, rfl⟩ <;>
  dsimp only <;>
  [rw [← compl_Ici]; rw [← compl_Iio]] <;>
  exact MeasurableSet.compl (GenerateMeasurable.basic _ (mem_range_self q))
Theorem: lift_rank_eq_of_equiv_equiv
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

Proof steps:
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : ZeroHom R R'
j : M ≃+ M'
hi : Bijective ⇑i
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
x✝¹ : R
x✝ : i x✝¹ = 0
⊢ i x✝¹ = i 0
state_after: no goals
tactic: rwa [i.map_zero]
state_before: R : Type u
R' : Type u'
M M₁ : Type v
M' : Type v'
inst✝⁹ : Ring R
inst✝⁸ : Ring R'
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Module R' M'
inst✝ : Module R' M₁
i : ZeroHom R R'
j : M ≃+ M'
hi : Bijective ⇑i
hc : ∀ (r : R) (m : M), j (r • m) = i r • j m
x✝¹ : R
x✝ : M'
⊢ i x✝¹ • x✝ = j (x✝¹ • ↑j.symm x✝)
state_after: no goals
tactic: erw [hc, j.apply_symm_apply]
Theorem: LinearMap.lTensor_bij_iff_rTensor_bij
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f : N →ₗ[R] P
⊢ Function.Bijective ⇑(lTensor M f) ↔ Function.Bijective ⇑(rTensor M f)
state_after: no goals
tactic: simp [← comm_comp_rTensor_comp_comm_eq]
Theorem: CategoryTheory.GrothendieckTopology.intersection_covering
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
⊢ R ⊓ S ∈ J.sieves X
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
⊢ ∀ (Y : C) (f : Y ⟶ X), R.arrows f → Sieve.pullback f (R ⊓ S) ∈ J.sieves Y
tactic: apply J.transitive rj _ fun Y f Hf => _
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
⊢ ∀ (Y : C) (f : Y ⟶ X), R.arrows f → Sieve.pullback f (R ⊓ S) ∈ J.sieves Y
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : R.arrows f
⊢ Sieve.pullback f (R ⊓ S) ∈ J.sieves Y
tactic: intros Y f hf
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : R.arrows f
⊢ Sieve.pullback f (R ⊓ S) ∈ J.sieves Y
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : R.arrows f
⊢ ⊤ ⊓ Sieve.pullback f S ∈ J.sieves Y
tactic: rw [Sieve.pullback_inter, R.pullback_eq_top_of_mem hf]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y✝ : C
S R : Sieve X
J : GrothendieckTopology C
rj : R ∈ J.sieves X
sj : S ∈ J.sieves X
Y : C
f : Y ⟶ X
hf : R.arrows f
⊢ ⊤ ⊓ Sieve.pullback f S ∈ J.sieves Y
state_after: no goals
tactic: simp [sj]
Theorem: Batteries.BinomialHeap.Imp.Heap.WF.singleton
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
a : α✝
le : α✝ → α✝ → Bool
⊢ 0 ≤ 0
state_after: no goals
tactic: decide
Theorem: SimplexCategory.δ_comp_σ_of_le
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
⊢ δ i.castSucc ≫ σ j.succ = σ j ≫ δ i
state_after: case a.h.h
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
k : Fin ([n + 1].len + 1)
⊢ (Hom.toOrderHom (δ i.castSucc ≫ σ j.succ)) k = (Hom.toOrderHom (σ j ≫ δ i)) k
tactic: ext k : 3
state_before: case a.h.h
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
k : Fin ([n + 1].len + 1)
⊢ (Hom.toOrderHom (δ i.castSucc ≫ σ j.succ)) k = (Hom.toOrderHom (σ j ≫ δ i)) k
state_after: case a.h.h
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
k : Fin ([n + 1].len + 1)
⊢ j.succ.predAbove (i.castSucc.succAbove k) = i.succAbove (j.predAbove k)
tactic: dsimp [σ, δ]
state_before: case a.h.h
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
k : Fin ([n + 1].len + 1)
⊢ j.succ.predAbove (i.castSucc.succAbove k) = i.succAbove (j.predAbove k)
state_after: case a.h.h.inl
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
k : Fin ([n + 1].len + 1)
hik : i ≤ k
⊢ j.succ.predAbove (i.castSucc.succAbove k) = i.succAbove (j.predAbove k)

case a.h.h.inr
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ j.castSucc
k : Fin ([n + 1].len + 1)
hik : k < i
⊢ j.succ.predAbove (i.castSucc.succAbove k) = i.succAbove (j.predAbove k)
tactic: rcases le_or_lt i k with (hik | hik)
Theorem: CategoryTheory.NonPreadditiveAbelian.add_neg
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a b : X ⟶ Y
⊢ a + -b = a - b
state_after: no goals
tactic: rw [add_def, neg_neg]
Theorem: Finset.sup'_id_eq_csSup
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLattice α
s : Finset α
hs : s.Nonempty
⊢ s.sup' hs id = sSup ↑s
state_after: no goals
tactic: rw [sup'_eq_csSup_image s hs, Set.image_id]
Theorem: Finset.sum_update_of_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
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 β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ ∏ x ∈ s, update f i b x = b * ∏ x ∈ s \ {i}, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ (∏ x ∈ s ∩ {i}, b) * ∏ x ∈ s \ {i}, f x = b * ∏ x ∈ s \ {i}, f x
tactic: rw [update_eq_piecewise, prod_piecewise]
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 β
inst✝ : DecidableEq α
s : Finset α
i : α
h : i ∈ s
f : α → β
b : β
⊢ (∏ x ∈ s ∩ {i}, b) * ∏ x ∈ s \ {i}, f x = b * ∏ x ∈ s \ {i}, f x
state_after: no goals
tactic: simp [h]
Theorem: AntilipschitzWith.mul_le_edist
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
⊢ (↑K)⁻¹ * edist x y ≤ edist (f x) (f y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
⊢ edist x y / ↑K ≤ edist (f x) (f y)
tactic: rw [mul_comm, ← div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
⊢ edist x y / ↑K ≤ edist (f x) (f y)
state_after: no goals
tactic: exact ENNReal.div_le_of_le_mul' (hf x y)
Theorem: Multiset.toFinset_singleton
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
a : α
⊢ {a}.toFinset = {a}
state_after: no goals
tactic: rw [← cons_zero, toFinset_cons, toFinset_zero, LawfulSingleton.insert_emptyc_eq]
Theorem: Polynomial.Monic.mul_left_eq_zero_iff
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 : R[X]
h : p.Monic
q : R[X]
⊢ q * p = 0 ↔ q = 0
state_after: no goals
tactic: by_cases hq : q = 0 <;> simp [h.mul_left_ne_zero, hq]
Theorem: WriterT.goto_mkLabel
File: Mathlib/Control/Monad/Cont.lean

Proof steps:
state_before: m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β ω : Type u
inst✝ : EmptyCollection ω
x : Label (α × ω) m β
i : α
⊢ goto (mkLabel x) i = monadLift (goto x (i, ∅))
state_after: case mk
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β ω : Type u
inst✝ : EmptyCollection ω
i : α
apply✝ : α × ω → m β
⊢ goto (mkLabel { apply := apply✝ }) i = monadLift (goto { apply := apply✝ } (i, ∅))
tactic: cases x
state_before: case mk
m : Type u → Type v
inst✝¹ : Monad m
α : Type u_1
β ω : Type u
inst✝ : EmptyCollection ω
i : α
apply✝ : α × ω → m β
⊢ goto (mkLabel { apply := apply✝ }) i = monadLift (goto { apply := apply✝ } (i, ∅))
state_after: no goals
tactic: rfl