tasksource/leandojo huggingface dataset:
Theorem: Nat.sum_properDivisors_dvd
File: Mathlib/NumberTheory/Divisors.lean

tactic: cases' n with n
state_before: n : ℕ
h : ∑ x in properDivisors n, x ∣ n
⊢ ∑ x in properDivisors n, x = 1 ∨ ∑ x in properDivisors n, x = n

tactic: simp
state_before: case zero
h : ∑ x in properDivisors zero, x ∣ zero
⊢ ∑ x in properDivisors zero, x = 1 ∨ ∑ x in properDivisors zero, x = zero

tactic: cases' n with n
state_before: case succ
n : ℕ
h : ∑ x in properDivisors (succ n), x ∣ succ n
⊢ ∑ x in properDivisors (succ n), x = 1 ∨ ∑ x in properDivisors (succ n), x = succ n

tactic: contrapose! h
state_before: case succ.zero
h : ∑ x in properDivisors (succ zero), x ∣ succ zero
⊢ ∑ x in properDivisors (succ zero), x = 1 ∨ ∑ x in properDivisors (succ zero), x = succ zero

tactic: simp
state_before: case succ.zero
h : ∑ x in properDivisors (succ zero), x ≠ 1 ∧ ∑ x in properDivisors (succ zero), x ≠ succ zero
⊢ ¬∑ x in properDivisors (succ zero), x ∣ succ zero

tactic: rw [or_iff_not_imp_right]
state_before: case succ.succ
n : ℕ
h : ∑ x in properDivisors (succ (succ n)), x ∣ succ (succ n)
⊢ ∑ x in properDivisors (succ (succ n)), x = 1 ∨ ∑ x in properDivisors (succ (succ n)), x = succ (succ n)

tactic: intro ne_n
state_before: case succ.succ
n : ℕ
h : ∑ x in properDivisors (succ (succ n)), x ∣ succ (succ n)
⊢ ¬∑ x in properDivisors (succ (succ n)), x = succ (succ n) → ∑ x in properDivisors (succ (succ n)), x = 1

tactic: have hlt : (∑ x in n.succ.succ.properDivisors, x) < n.succ.succ :=
  lt_of_le_of_ne (Nat.le_of_dvd (Nat.succ_pos _) h) ne_n
state_before: case succ.succ
n : ℕ
h : ∑ x in properDivisors (succ (succ n)), x ∣ succ (succ n)
ne_n : ¬∑ x in properDivisors (succ (succ n)), x = succ (succ n)
⊢ ∑ x in properDivisors (succ (succ n)), x = 1

tactic: symm
state_before: case succ.succ
n : ℕ
h : ∑ x in properDivisors (succ (succ n)), x ∣ succ (succ n)
ne_n : ¬∑ x in properDivisors (succ (succ n)), x = succ (succ n)
hlt : ∑ x in properDivisors (succ (succ n)), x < succ (succ n)
⊢ ∑ x in properDivisors (succ (succ n)), x = 1

tactic: rw [← mem_singleton,
  eq_properDivisors_of_subset_of_sum_eq_sum
    (singleton_subset_iff.2 (mem_properDivisors.2 ⟨h, hlt⟩)) sum_singleton,
  mem_properDivisors]
state_before: case succ.succ
n : ℕ
h : ∑ x in properDivisors (succ (succ n)), x ∣ succ (succ n)
ne_n : ¬∑ x in properDivisors (succ (succ n)), x = succ (succ n)
hlt : ∑ x in properDivisors (succ (succ n)), x < succ (succ n)
⊢ 1 = ∑ x in properDivisors (succ (succ n)), x

tactic: refine' ⟨one_dvd _, Nat.succ_lt_succ (Nat.succ_pos _)⟩
state_before: case succ.succ
n : ℕ
h : ∑ x in properDivisors (succ (succ n)), x ∣ succ (succ n)
ne_n : ¬∑ x in properDivisors (succ (succ n)), x = succ (succ n)
hlt : ∑ x in properDivisors (succ (succ n)), x < succ (succ n)
⊢ 1 ∣ succ (succ n) ∧ 1 < succ (succ n)
Theorem: Int.ofNat_mul_negOfNat
File: Std/Data/Int/Lemmas.lean

tactic: cases n <;> rfl
state_before: m n : Nat
⊢ ↑m * negOfNat n = negOfNat (m * n)
Theorem: Finset.mem_sum
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: refine' s.induction_on (by simp) _
state_before: ι : Type ?u.865375
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
f : α → Multiset β
s : Finset α
b : β
⊢ b ∈ ∑ x in s, f x ↔ ∃ a, a ∈ s ∧ b ∈ f a

tactic: simp
state_before: ι : Type ?u.865375
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
f : α → Multiset β
s : Finset α
b : β
⊢ b ∈ ∑ x in ∅, f x ↔ ∃ a, a ∈ ∅ ∧ b ∈ f a

tactic: intro a t hi ih
state_before: ι : Type ?u.865375
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
f : α → Multiset β
s : Finset α
b : β
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    ¬a ∈ s →
      (b ∈ ∑ x in s, f x ↔ ∃ a, a ∈ s ∧ b ∈ f a) → (b ∈ ∑ x in insert a s, f x ↔ ∃ a_3, a_3 ∈ insert a s ∧ b ∈ f a_3)

tactic: simp [sum_insert hi, ih, or_and_right, exists_or]
state_before: ι : Type ?u.865375
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
f : α → Multiset β
s : Finset α
b : β
a : α
t : Finset α
hi : ¬a ∈ t
ih : b ∈ ∑ x in t, f x ↔ ∃ a, a ∈ t ∧ b ∈ f a
⊢ b ∈ ∑ x in insert a t, f x ↔ ∃ a_1, a_1 ∈ insert a t ∧ b ∈ f a_1
Theorem: Computation.results_of_terminates'
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← get_eq_of_mem _ h]
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
T : Terminates s
a : α
h : a ∈ s
⊢ Results s a (length s)

tactic: apply results_of_terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
T : Terminates s
a : α
h : a ∈ s
⊢ Results s (get s) (length s)
Theorem: Finset.Ico_eq_cons_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: classical rw [cons_eq_insert, Ioo_insert_left h]
state_before: ι : Type ?u.109231
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a < b
⊢ Ico a b = cons a (Ioo a b) (_ : ¬a ∈ Ioo a b)

tactic: rw [cons_eq_insert, Ioo_insert_left h]
state_before: ι : Type ?u.109231
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b c : α
h : a < b
⊢ Ico a b = cons a (Ioo a b) (_ : ¬a ∈ Ioo a b)
Theorem: mem_closure_iff_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [mem_closure_iff_nhds_basis ((𝓝 1 : Filter G).basis_sets.nhds_of_one x)]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ x ∈ closure s ↔ ∀ (U : Set G), U ∈ 𝓝 1 → ∃ y, y ∈ s ∧ y / x ∈ U

tactic: simp_rw [Set.mem_setOf, id]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s✝ : Set α
x✝ : α
x : G
s : Set G
⊢ (∀ (i : Set G), i ∈ 𝓝 1 → ∃ y, y ∈ s ∧ y ∈ {y | y / x ∈ id i}) ↔ ∀ (U : Set G), U ∈ 𝓝 1 → ∃ y, y ∈ s ∧ y / x ∈ U
Theorem: Finset.sized_shadow_iff
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: refine' ⟨fun h𝒜 s hs => _, Set.Sized.shadow⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h : ¬∅ ∈ 𝒜
⊢ Set.Sized r ↑((∂ ) 𝒜) ↔ Set.Sized (r + 1) ↑𝒜

tactic: obtain ⟨a, ha⟩ := nonempty_iff_ne_empty.2 (ne_of_mem_of_not_mem hs h)
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
h : ¬∅ ∈ 𝒜
h𝒜 : Set.Sized r ↑((∂ ) 𝒜)
s : Finset α
hs : s ∈ ↑𝒜
⊢ card s = r + 1

tactic: rw [← h𝒜 (erase_mem_shadow hs ha), card_erase_add_one ha]
state_before: case intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a✝ : α
k r : ℕ
h : ¬∅ ∈ 𝒜
h𝒜 : Set.Sized r ↑((∂ ) 𝒜)
s : Finset α
hs : s ∈ ↑𝒜
a : α
ha : a ∈ s
⊢ card s = r + 1
Theorem: Multiset.map_le_map_iff
File: Mathlib/Data/Multiset/Basic.lean

tactic: classical
  refine' ⟨fun h => le_iff_count.mpr fun a => _, map_le_map⟩
  simpa [count_map_eq_count' f _ hf] using le_iff_count.mp h (f a)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.428121
f : α → β
hf : Injective f
s t : Multiset α
⊢ map f s ≤ map f t ↔ s ≤ t

tactic: refine' ⟨fun h => le_iff_count.mpr fun a => _, map_le_map⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.428121
f : α → β
hf : Injective f
s t : Multiset α
⊢ map f s ≤ map f t ↔ s ≤ t

tactic: simpa [count_map_eq_count' f _ hf] using le_iff_count.mp h (f a)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.428121
f : α → β
hf : Injective f
s t : Multiset α
h : map f s ≤ map f t
a : α
⊢ count a s ≤ count a t
Theorem: PSigma.Lex.mono
File: Mathlib/Data/Sigma/Lex.lean

tactic: obtain ⟨a, b, hij⟩ | ⟨i, hab⟩ := h
state_before: ι : Sort u_1
α : ι → Sort u_2
r r₁✝ r₂✝ : ι → ι → Prop
s s₁✝ s₂✝ : (i : ι) → α i → α i → Prop
r₁ r₂ : ι → ι → Prop
s₁ s₂ : (i : ι) → α i → α i → Prop
hr : ∀ (a b : ι), r₁ a b → r₂ a b
hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b
a b : (i : ι) ×' α i
h : Lex r₁ s₁ a b
⊢ Lex r₂ s₂ a b

tactic: exact Lex.left _ _ (hr _ _ hij)
state_before: case left
ι : Sort u_1
α : ι → Sort u_2
r r₁✝ r₂✝ : ι → ι → Prop
s s₁✝ s₂✝ : (i : ι) → α i → α i → Prop
r₁ r₂ : ι → ι → Prop
s₁ s₂ : (i : ι) → α i → α i → Prop
hr : ∀ (a b : ι), r₁ a b → r₂ a b
hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b
a₁✝ : ι
a : α a₁✝
a₂✝ : ι
b : α a₂✝
hij : r₁ a₁✝ a₂✝
⊢ Lex r₂ s₂ { fst := a₁✝, snd := a } { fst := a₂✝, snd := b }

tactic: exact Lex.right _ (hs _ _ _ hab)
state_before: case right
ι : Sort u_1
α : ι → Sort u_2
r r₁✝ r₂✝ : ι → ι → Prop
s s₁✝ s₂✝ : (i : ι) → α i → α i → Prop
r₁ r₂ : ι → ι → Prop
s₁ s₂ : (i : ι) → α i → α i → Prop
hr : ∀ (a b : ι), r₁ a b → r₂ a b
hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b
i : ι
b₁✝ b₂✝ : α i
hab : s₁ i b₁✝ b₂✝
⊢ Lex r₂ s₂ { fst := i, snd := b₁✝ } { fst := i, snd := b₂✝ }
Theorem: ContinuousLinearMap.intervalIntegral_apply
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp_rw [intervalIntegral_eq_integral_uIoc, ← integral_apply hφ.def v, coe_smul', Pi.smul_apply]
state_before: ι : Type ?u.14415591
𝕜 : Type u_1
E : Type u_3
F : Type u_2
A : Type ?u.14415603
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : CompleteSpace E
inst✝⁴ : NormedSpace ℝ E
a✝ b✝ : ℝ
μ : MeasureTheory.Measure ℝ
f : ℝ → E
inst✝³ : IsROrC 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
a b : ℝ
φ : ℝ → F →L[𝕜] E
hφ : IntervalIntegrable φ μ a b
v : F
⊢ ↑(∫ (x : ℝ) in a..b, φ x ∂μ) v = ∫ (x : ℝ) in a..b, ↑(φ x) v ∂μ
Theorem: Array.isEqvAux_self
File: src/lean/Init/Data/Array/DecidableEq.lean

tactic: unfold Array.isEqvAux
state_before: α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
⊢ isEqvAux a a (_ : size a = size a) (fun x y => decide (x = y)) i = true

tactic: split
state_before: α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
⊢ (if h : i < size a then
      let_fun this := (_ : i < size a);
      decide (a[i] = a[i]) && isEqvAux a a (_ : size a = size a) (fun x y => decide (x = y)) (i + 1)
    else true) =
    true

tactic: case inl h => simp [h, isEqvAux_self a (i+1)]
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
h✝ : i < size a
⊢ (let_fun this := (_ : i < size a);
    decide (a[i] = a[i]) && isEqvAux a a (_ : size a = size a) (fun x y => decide (x = y)) (i + 1)) =
    true

case inr
α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
h✝ : ¬i < size a
⊢ true = true

tactic: case inr h => simp [h]
state_before: case inr
α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
h✝ : ¬i < size a
⊢ true = true

tactic: simp [h, isEqvAux_self a (i+1)]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
h : i < size a
⊢ (let_fun this := (_ : i < size a);
    decide (a[i] = a[i]) && isEqvAux a a (_ : size a = size a) (fun x y => decide (x = y)) (i + 1)) =
    true

tactic: simp [h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a : Array α
i : Nat
h : ¬i < size a
⊢ true = true
Theorem: LinearMap.trace_tensorProduct'
File: Mathlib/LinearAlgebra/Trace.lean

tactic: have h := ext_iff.1 (ext_iff.1 (trace_tensorProduct R M N) f) g
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.584160
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
g : N →ₗ[R] N
⊢ ↑(trace R (M ⊗[R] N)) (TensorProduct.map f g) = ↑(trace R M) f * ↑(trace R N) g

tactic: simp only [compr₂_apply, mapBilinear_apply, compl₁₂_apply, lsmul_apply,
  Algebra.id.smul_eq_mul] at h
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.584160
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
g : N →ₗ[R] N
h :
  ↑(↑(compr₂ (mapBilinear R M N M N) (trace R (M ⊗[R] N))) f) g = ↑(↑(compl₁₂ (lsmul R R) (trace R M) (trace R N)) f) g
⊢ ↑(trace R (M ⊗[R] N)) (TensorProduct.map f g) = ↑(trace R M) f * ↑(trace R N) g

tactic: exact h
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.584160
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
g : N →ₗ[R] N
h : ↑(trace R (M ⊗[R] N)) (TensorProduct.map f g) = ↑(trace R M) f * ↑(trace R N) g
⊢ ↑(trace R (M ⊗[R] N)) (TensorProduct.map f g) = ↑(trace R M) f * ↑(trace R N) g
Theorem: BilinForm.nondegenerate_toBilin'_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [Matrix.nondegenerate_toBilin'_iff, Matrix.nondegenerate_iff_det_ne_zero]
state_before: R : Type ?u.2956365
M✝ : Type ?u.2956368
inst✝¹⁹ : Semiring R
inst✝¹⁸ : AddCommMonoid M✝
inst✝¹⁷ : Module R M✝
R₁ : Type ?u.2956404
M₁ : Type ?u.2956407
inst✝¹⁶ : Ring R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type ?u.2957016
M₂ : Type ?u.2957019
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type ?u.2957206
M₃ : Type ?u.2957209
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type ?u.2957797
K : Type ?u.2957800
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type u_2
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
M : Matrix ι ι A
⊢ Nondegenerate (↑toBilin' M) ↔ det M ≠ 0
Theorem: map_iInf
File: Mathlib/Order/Hom/CompleteLattice.lean

tactic: simp [iInf, ← Set.range_comp, Function.comp]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.6894
δ : Type ?u.6897
ι : Sort u_4
κ : ι → Sort ?u.6905
inst✝² : InfSet α
inst✝¹ : InfSet β
inst✝ : sInfHomClass F α β
f : F
g : ι → α
⊢ ↑f (⨅ (i : ι), g i) = ⨅ (i : ι), ↑f (g i)
Theorem: MeasureTheory.tendsto_integral_approxOn_of_measurable_of_range_subset
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp
state_before: α : Type ?u.1279631
E : Type ?u.1279634
F : Type ?u.1279637
𝕜 : Type ?u.1279640
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1282331
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
fmeas : Measurable f
hf : Integrable f
s : Set E
inst✝ : SeparableSpace ↑s
hs : range f ∪ {0} ⊆ s
n : ℕ
⊢ 0 ∈ range f ∪ {0}

tactic: apply tendsto_integral_approxOn_of_measurable hf fmeas _ _ (integrable_zero _ _ _)
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1279637
𝕜 : Type ?u.1279640
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1282331
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
fmeas : Measurable f
hf : Integrable f
s : Set E
inst✝ : SeparableSpace ↑s
hs : range f ∪ {0} ⊆ s
⊢ Tendsto (fun n => SimpleFunc.integral μ (approxOn f fmeas s 0 (_ : 0 ∈ s) n)) atTop (𝓝 (∫ (x : α), f x ∂μ))

tactic: exact eventually_of_forall fun x => subset_closure (hs (Set.mem_union_left _ (mem_range_self _)))
state_before: α : Type u_2
E : Type u_1
F : Type ?u.1279637
𝕜 : Type ?u.1279640
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1282331
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
f : α → E
fmeas : Measurable f
hf : Integrable f
s : Set E
inst✝ : SeparableSpace ↑s
hs : range f ∪ {0} ⊆ s
⊢ ∀ᵐ (x : α) ∂μ, f x ∈ closure s
Theorem: PEquiv.refl_trans
File: Mathlib/Data/PEquiv.lean

tactic: ext
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ PEquiv.trans (PEquiv.refl α) f = f

tactic: dsimp [PEquiv.trans]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : β
⊢ a✝ ∈ ↑(PEquiv.trans (PEquiv.refl α) f) x✝ ↔ a✝ ∈ ↑f x✝

tactic: rfl
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : β
⊢ a✝ ∈ ↑f x✝ ↔ a✝ ∈ ↑f x✝
Theorem: CochainComplex.of_d_ne
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: dsimp [of]
state_before: ι : Type ?u.219028
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
α : Type u_1
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X n ⟶ X (n + 1)
sq : ∀ (n : α), d n ≫ d (n + 1) = 0
i j : α
h : i + 1 ≠ j
⊢ HomologicalComplex.d (of X d sq) i j = 0

tactic: rw [dif_neg h]
state_before: ι : Type ?u.219028
V : Type u
inst✝⁴ : Category V
inst✝³ : HasZeroMorphisms V
α : Type u_1
inst✝² : AddRightCancelSemigroup α
inst✝¹ : One α
inst✝ : DecidableEq α
X : α → V
d : (n : α) → X n ⟶ X (n + 1)
sq : ∀ (n : α), d n ≫ d (n + 1) = 0
i j : α
h : i + 1 ≠ j
⊢ (if h : i + 1 = j then d i ≫ eqToHom (_ : X (i + 1) = X j) else 0) = 0
Theorem: Lean.Data.AC.Context.unwrap_isNeutral
File: src/lean/Init/Data/AC.lean

tactic: simp [ContextInformation.isNeutral, Option.isSome, EvalInformation.evalOp, EvalInformation.evalVar]
state_before: α : Sort u_1
ctx : Context α
x : Nat
⊢ ContextInformation.isNeutral ctx x = true → IsNeutral (EvalInformation.evalOp ctx) (EvalInformation.evalVar ctx x)

tactic: match (var ctx x).neutral with
| some hn => intro; assumption
| none => intro; contradiction
state_before: α : Sort u_1
ctx : Context α
x : Nat
⊢ (match (var ctx x).neutral with
      | some val => true
      | none => false) =
      true →
    IsNeutral ctx.op (var ctx x).value

tactic: intro
state_before: α : Sort u_1
ctx : Context α
x : Nat
hn : IsNeutral ctx.op (var ctx x).value
⊢ (match some hn with
      | some val => true
      | none => false) =
      true →
    IsNeutral ctx.op (var ctx x).value

tactic: assumption
state_before: α : Sort u_1
ctx : Context α
x : Nat
hn : IsNeutral ctx.op (var ctx x).value
a✝ :
  (match some hn with
    | some val => true
    | none => false) =
    true
⊢ IsNeutral ctx.op (var ctx x).value

tactic: intro
state_before: α : Sort u_1
ctx : Context α
x : Nat
⊢ (match none with
      | some val => true
      | none => false) =
      true →
    IsNeutral ctx.op (var ctx x).value

tactic: contradiction
state_before: α : Sort u_1
ctx : Context α
x : Nat
a✝ :
  (match none with
    | some val => true
    | none => false) =
    true
⊢ IsNeutral ctx.op (var ctx x).value
Theorem: CategoryTheory.exact_f_d
File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
X Y : C
f : X ⟶ Y
⊢ f ≫ d f = 0

tactic: rw [Category.assoc, kernel.condition]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
inst✝ : EnoughInjectives C
X Y : C
f : X ⟶ Y
⊢ (kernel.ι (d f) ≫ cokernel.π f) ≫ ι (cokernel f) = 0
Theorem: MultilinearMap.mk_coe
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' f : MultilinearMap R M₁ M₂
h₁ :
  ∀ [inst : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (x y : M₁ i),
    ↑f (update m i (x + y)) = ↑f (update m i x) + ↑f (update m i y)
h₂ :
  ∀ [inst : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (c : R) (x : M₁ i),
    ↑f (update m i (c • x)) = c • ↑f (update m i x)
⊢ { toFun := ↑f, map_add' := h₁, map_smul' := h₂ } = f

tactic: rfl
state_before: case H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' f : MultilinearMap R M₁ M₂
h₁ :
  ∀ [inst : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (x y : M₁ i),
    ↑f (update m i (x + y)) = ↑f (update m i x) + ↑f (update m i y)
h₂ :
  ∀ [inst : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι) (c : R) (x : M₁ i),
    ↑f (update m i (c • x)) = c • ↑f (update m i x)
x✝ : (i : ι) → M₁ i
⊢ ↑{ toFun := ↑f, map_add' := h₁, map_smul' := h₂ } x✝ = ↑f x✝
Theorem: AlgHom.fst_prod
File: Mathlib/Algebra/Algebra/Prod.lean

tactic: ext
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
⊢ comp (fst R B C) (prod f g) = f

tactic: rfl
state_before: case H
R : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : Semiring C
inst✝ : Algebra R C
f : A →ₐ[R] B
g : A →ₐ[R] C
x✝ : A
⊢ ↑(comp (fst R B C) (prod f g)) x✝ = ↑f x✝
Theorem: FirstOrder.Language.Term.realize_lt
File: Mathlib/ModelTheory/Order.lean

tactic: simp [Term.lt, lt_iff_le_not_le]
state_before: L : Language
α : Type w
M : Type w'
n : ℕ
inst✝³ : IsOrdered L
inst✝² : Structure L M
inst✝¹ : Preorder M
inst✝ : OrderedStructure L M
t₁ t₂ : Term L (α ⊕ Fin n)
v : α → M
xs : Fin n → M
⊢ BoundedFormula.Realize (lt t₁ t₂) v xs ↔ realize (Sum.elim v xs) t₁ < realize (Sum.elim v xs) t₂
Theorem: FirstOrder.Language.Term.realize_mem
File: Mathlib/ModelTheory/Substructures.lean

tactic: induction' t with a n f ts ih
state_before: L : Language
M : Type w
N : Type ?u.14398
P : Type ?u.14401
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
α : Type u_1
t : Term L α
xs : α → M
h : ∀ (a : α), xs a ∈ S
⊢ realize xs t ∈ S

tactic: exact h a
state_before: case var
L : Language
M : Type w
N : Type ?u.14398
P : Type ?u.14401
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
α : Type u_1
xs : α → M
h : ∀ (a : α), xs a ∈ S
a : α
⊢ realize xs (var a) ∈ S

tactic: exact Substructure.fun_mem _ _ _ ih
state_before: case func
L : Language
M : Type w
N : Type ?u.14398
P : Type ?u.14401
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S : Substructure L M
α : Type u_1
xs : α → M
h : ∀ (a : α), xs a ∈ S
n : ℕ
f : Functions L n
ts : Fin n → Term L α
ih : ∀ (a : Fin n), realize xs (ts a) ∈ S
⊢ realize xs (func f ts) ∈ S