tasksource/leandojo huggingface dataset:
Theorem: CochainComplex.mk_d_1_0
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: change ite (1 = 0 + 1) (d₀ ≫ 𝟙 X₁) 0 = d₀
state_before: ι : Type ?u.323151
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₀ ⟶ X₁
d₁ : X₁ ⟶ X₂
s : d₀ ≫ d₁ = 0
succ :
  (t : (X₀ : V) ×' (X₁ : V) ×' (X₂ : V) ×' (d₀ : X₀ ⟶ X₁) ×' (d₁ : X₁ ⟶ X₂) ×' d₀ ≫ d₁ = 0) →
    (X₃ : V) ×' (d₂ : t.snd.snd.fst ⟶ X₃) ×' t.snd.snd.snd.snd.fst ≫ d₂ = 0
⊢ HomologicalComplex.d (mk X₀ X₁ X₂ d₀ d₁ s succ) 0 1 = d₀

tactic: rw [if_pos rfl, Category.comp_id]
state_before: ι : Type ?u.323151
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
X₀ X₁ X₂ : V
d₀ : X₀ ⟶ X₁
d₁ : X₁ ⟶ X₂
s : d₀ ≫ d₁ = 0
succ :
  (t : (X₀ : V) ×' (X₁ : V) ×' (X₂ : V) ×' (d₀ : X₀ ⟶ X₁) ×' (d₁ : X₁ ⟶ X₂) ×' d₀ ≫ d₁ = 0) →
    (X₃ : V) ×' (d₂ : t.snd.snd.fst ⟶ X₃) ×' t.snd.snd.snd.snd.fst ≫ d₂ = 0
⊢ (if 1 = 0 + 1 then d₀ ≫ 𝟙 X₁ else 0) = d₀
Theorem: AddMonoidAlgebra.mem_grade_iff'
File: Mathlib/Algebra/MonoidAlgebra/Grading.lean

tactic: rw [mem_grade_iff, Finsupp.support_subset_singleton']
state_before: M : Type u_2
ι : Type ?u.7453
R : Type u_1
inst✝¹ : DecidableEq M
inst✝ : CommSemiring R
m : M
a : AddMonoidAlgebra R M
⊢ a ∈ grade R m ↔ a ∈ LinearMap.range (Finsupp.lsingle m)

tactic: apply exists_congr
state_before: M : Type u_2
ι : Type ?u.7453
R : Type u_1
inst✝¹ : DecidableEq M
inst✝ : CommSemiring R
m : M
a : AddMonoidAlgebra R M
⊢ (∃ b, a = Finsupp.single m b) ↔ a ∈ LinearMap.range (Finsupp.lsingle m)

tactic: intro r
state_before: case h
M : Type u_2
ι : Type ?u.7453
R : Type u_1
inst✝¹ : DecidableEq M
inst✝ : CommSemiring R
m : M
a : AddMonoidAlgebra R M
⊢ ∀ (a_1 : R), a = Finsupp.single m a_1 ↔ ↑(Finsupp.lsingle m) a_1 = a

tactic: constructor <;> exact Eq.symm
state_before: case h
M : Type u_2
ι : Type ?u.7453
R : Type u_1
inst✝¹ : DecidableEq M
inst✝ : CommSemiring R
m : M
a : AddMonoidAlgebra R M
r : R
⊢ a = Finsupp.single m r ↔ ↑(Finsupp.lsingle m) r = a
Theorem: List.prod_take_mul_prod_drop
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp [Nat.zero_le]
state_before: ι : Type ?u.51930
α : Type ?u.51933
M : Type u_1
N : Type ?u.51939
P : Type ?u.51942
M₀ : Type ?u.51945
G : Type ?u.51948
R : Type ?u.51951
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
i : ℕ
⊢ prod (take i []) * prod (drop i []) = prod []

tactic: simp
state_before: ι : Type ?u.51930
α : Type ?u.51933
M : Type u_1
N : Type ?u.51939
P : Type ?u.51942
M₀ : Type ?u.51945
G : Type ?u.51948
R : Type ?u.51951
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
L : List M
⊢ prod (take 0 L) * prod (drop 0 L) = prod L

tactic: dsimp
state_before: ι : Type ?u.51930
α : Type ?u.51933
M : Type u_1
N : Type ?u.51939
P : Type ?u.51942
M₀ : Type ?u.51945
G : Type ?u.51948
R : Type ?u.51951
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
n : ℕ
⊢ prod (take (n + 1) (h :: t)) * prod (drop (n + 1) (h :: t)) = prod (h :: t)

tactic: rw [prod_cons, prod_cons, mul_assoc, prod_take_mul_prod_drop t]
state_before: ι : Type ?u.51930
α : Type ?u.51933
M : Type u_1
N : Type ?u.51939
P : Type ?u.51942
M₀ : Type ?u.51945
G : Type ?u.51948
R : Type ?u.51951
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
n : ℕ
⊢ prod (h :: take n t) * prod (drop n t) = prod (h :: t)
Theorem: Primrec.of_graph
File: Mathlib/Computability/Primrec.lean

tactic: rcases h₁ with ⟨g, pg, hg : ∀ x, f x ≤ g x⟩
state_before: α : Type u_1
β : Type ?u.161236
γ : Type ?u.161239
δ : Type ?u.161242
σ : Type ?u.161245
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₁ : PrimrecBounded f
h₂ : PrimrecRel fun a b => f a = b
⊢ Primrec f

tactic: refine (nat_findGreatest pg h₂).of_eq fun n => ?_
state_before: case intro.intro
α : Type u_1
β : Type ?u.161236
γ : Type ?u.161239
δ : Type ?u.161242
σ : Type ?u.161245
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₂ : PrimrecRel fun a b => f a = b
g : α → ℕ
pg : Primrec g
hg : ∀ (x : α), f x ≤ g x
⊢ Primrec f

tactic: exact (Nat.findGreatest_spec (P := fun b => f n = b) (hg n) rfl).symm
state_before: case intro.intro
α : Type u_1
β : Type ?u.161236
γ : Type ?u.161239
δ : Type ?u.161242
σ : Type ?u.161245
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : α → ℕ
h₂ : PrimrecRel fun a b => f a = b
g : α → ℕ
pg : Primrec g
hg : ∀ (x : α), f x ≤ g x
n : α
⊢ Nat.findGreatest (fun b => f n = b) (g n) = f n
Theorem: sdiff_symmDiff_eq_sup
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, symmDiff_sdiff_eq_sup, sup_comm]
state_before: ι : Type ?u.32704
α : Type u_1
β : Type ?u.32710
π : ι → Type ?u.32715
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ (a \ b) ∆ b = a ⊔ b
Theorem: Finsupp.unique_ext
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rwa [Unique.eq_default a]
state_before: α : Type u_1
β : Type ?u.26168
γ : Type ?u.26171
ι : Type ?u.26174
M : Type u_2
M' : Type ?u.26180
N : Type ?u.26183
P : Type ?u.26186
G : Type ?u.26189
H : Type ?u.26192
R : Type ?u.26195
S : Type ?u.26198
inst✝¹ : Zero M
inst✝ : Unique α
f g : α →₀ M
h : ↑f default = ↑g default
a : α
⊢ ↑f a = ↑g a
Theorem: MeasureTheory.integrableOn_Ioi_comp_mul_right_iff
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: simpa only [mul_comm, MulZeroClass.mul_zero] using integrableOn_Ioi_comp_mul_left_iff f c ha
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
f : ℝ → E
c a : ℝ
ha : 0 < a
⊢ IntegrableOn (fun x => f (x * a)) (Ioi c) ↔ IntegrableOn f (Ioi (c * a))
Theorem: EuclideanDomain.dvd_lcm_left
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [lcm, hxy, div_zero]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : gcd x y = 0
⊢ x ∣ lcm x y

tactic: exact dvd_zero _
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : gcd x y = 0
⊢ x ∣ 0

tactic: rw [mul_right_comm, mul_assoc, ← hz]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : ¬gcd x y = 0
z : R
hz : y = gcd x y * z
⊢ x * z * gcd x y = x * y
Theorem: Pmf.apply_eq_zero_iff
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: rw [mem_support_iff, Classical.not_not]
state_before: α : Type u_1
β : Type ?u.6289
γ : Type ?u.6292
p : Pmf α
a : α
⊢ ↑p a = 0 ↔ ¬a ∈ support p
Theorem: gold_irrational
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: have := Nat.Prime.irrational_sqrt (show Nat.Prime 5 by norm_num)
state_before: ⊢ Irrational φ

tactic: have := this.rat_add 1
state_before: this : Irrational (sqrt ↑5)
⊢ Irrational φ

tactic: have := this.rat_mul (show (0.5 : ℚ) ≠ 0 by norm_num)
state_before: this✝ : Irrational (sqrt ↑5)
this : Irrational (↑1 + sqrt ↑5)
⊢ Irrational φ

tactic: convert this
state_before: this✝¹ : Irrational (sqrt ↑5)
this✝ : Irrational (↑1 + sqrt ↑5)
this : Irrational (↑0.5 * (↑1 + sqrt ↑5))
⊢ Irrational φ

tactic: norm_num
state_before: case h.e'_1
this✝¹ : Irrational (sqrt ↑5)
this✝ : Irrational (↑1 + sqrt ↑5)
this : Irrational (↑0.5 * (↑1 + sqrt ↑5))
⊢ φ = ↑0.5 * (↑1 + sqrt ↑5)

tactic: field_simp
state_before: case h.e'_1
this✝¹ : Irrational (sqrt ↑5)
this✝ : Irrational (↑1 + sqrt ↑5)
this : Irrational (↑0.5 * (↑1 + sqrt ↑5))
⊢ φ = 1 / 2 * (1 + sqrt 5)

tactic: norm_num
state_before: ⊢ Nat.Prime 5

tactic: norm_num
state_before: this✝ : Irrational (sqrt ↑5)
this : Irrational (↑1 + sqrt ↑5)
⊢ 0.5 ≠ 0
Theorem: PiNat.firstDiff_le_longestPrefix
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rw [longestPrefix, le_tsub_iff_right]
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : ¬x ∈ s
hy : y ∈ s
⊢ firstDiff x y ≤ longestPrefix x s

tactic: exact firstDiff_lt_shortestPrefixDiff hs hx hy
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : ¬x ∈ s
hy : y ∈ s
⊢ firstDiff x y + 1 ≤ shortestPrefixDiff x s

tactic: exact shortestPrefixDiff_pos hs ⟨y, hy⟩ hx
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : ¬x ∈ s
hy : y ∈ s
⊢ 1 ≤ shortestPrefixDiff x s
Theorem: Dfinsupp.comapDomain_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
⊢ comapDomain h hh (single (h k) x) = single k x

tactic: rw [comapDomain_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
⊢ ↑(comapDomain h hh (single (h k) x)) i = ↑(single k x) i

tactic: obtain rfl | hik := Decidable.eq_or_ne i k
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
⊢ ↑(single (h k) x) (h i) = ↑(single k x) i

tactic: rw [single_eq_same, single_eq_same]
state_before: case h.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
i : κ
x : β (h i)
⊢ ↑(single (h i) x) (h i) = ↑(single i x) i

tactic: rw [single_eq_of_ne hik.symm, single_eq_of_ne (hh.ne hik.symm)]
state_before: case h.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : (i : ι) → Zero (β i)
h : κ → ι
hh : Function.Injective h
k : κ
x : β (h k)
i : κ
hik : i ≠ k
⊢ ↑(single (h k) x) (h i) = ↑(single k x) i
Theorem: ProbabilityTheory.kernel.integral_deterministic
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.deterministic_apply, integral_dirac _ (g a)]
state_before: α : Type u_2
β : Type u_3
ι : Type ?u.401033
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f : β → E
g : α → β
a : α
hg : Measurable g
inst✝ : MeasurableSingletonClass β
⊢ (∫ (x : β), f x ∂↑(deterministic g hg) a) = f (g a)
Theorem: Vector.ne_cons_iff
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [Ne.def, eq_cons_iff a v v', not_and_or]
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α (Nat.succ n)
v' : Vector α n
⊢ v ≠ a ::ᵥ v' ↔ head v ≠ a ∨ tail v ≠ v'
Theorem: Complex.cos_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [two_mul, cos_add]
state_before: ⊢ cos (2 * ↑π) = 1
Theorem: Codisjoint.himp_inf_cancel_left
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [himp_inf_distrib, himp_self, inf_top_eq, h.himp_eq_right]
state_before: ι : Type ?u.74711
α : Type u_1
β : Type ?u.74717
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
h : Codisjoint a b
⊢ b ⇨ a ⊓ b = a
Theorem: Polynomial.nextCoeff_X_sub_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C c, nextCoeff_X_add_C]
state_before: R : Type u
S : Type v
a b c✝ d : R
n m : ℕ
inst✝² : Ring R
inst✝¹ : Nontrivial R
inst✝ : Ring S
c : S
⊢ nextCoeff (X - ↑C c) = -c
Theorem: Set.right_mem_Ico
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [lt_irrefl]
state_before: α : Type u_1
β : Type ?u.5009
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ Ico a b ↔ False
Theorem: Subgroup.rank_closure_finite_le_nat_card
File: Mathlib/GroupTheory/Finiteness.lean

tactic: haveI := Fintype.ofFinite s
state_before: M : Type ?u.118917
N : Type ?u.118920
inst✝⁴ : Monoid M
inst✝³ : AddMonoid N
G : Type u_1
H : Type ?u.118932
inst✝² : Group G
inst✝¹ : AddGroup H
s : Set G
inst✝ : Finite ↑s
⊢ Group.rank { x // x ∈ closure s } ≤ Nat.card ↑s

tactic: rw [Nat.card_eq_fintype_card, ← s.toFinset_card, ← rank_congr (congr_arg _ s.coe_toFinset)]
state_before: M : Type ?u.118917
N : Type ?u.118920
inst✝⁴ : Monoid M
inst✝³ : AddMonoid N
G : Type u_1
H : Type ?u.118932
inst✝² : Group G
inst✝¹ : AddGroup H
s : Set G
inst✝ : Finite ↑s
this : Fintype ↑s
⊢ Group.rank { x // x ∈ closure s } ≤ Nat.card ↑s

tactic: exact rank_closure_finset_le_card s.toFinset
state_before: M : Type ?u.118917
N : Type ?u.118920
inst✝⁴ : Monoid M
inst✝³ : AddMonoid N
G : Type u_1
H : Type ?u.118932
inst✝² : Group G
inst✝¹ : AddGroup H
s : Set G
inst✝ : Finite ↑s
this : Fintype ↑s
⊢ Group.rank { x // x ∈ closure ↑(Set.toFinset s) } ≤ Finset.card (Set.toFinset s)
Theorem: unique_subtype_iff_exists_unique
File: Mathlib/Logic/Unique.lean

tactic: congr
state_before: α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ { val := b, property := hb } = default

tactic: exact he b hb
state_before: case e_val
α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ b = a
Theorem: Finset.sum_boole
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp only [add_zero, mul_one, Finset.sum_const, nsmul_eq_mul, eq_self_iff_true,
  Finset.sum_const_zero, Finset.sum_ite, mul_zero]
state_before: ι : Type ?u.817559
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
s : Finset α
p : α → Prop
inst✝ : NonAssocSemiring β
hp : DecidablePred p
⊢ (∑ x in s, if p x then 1 else 0) = ↑(card (filter p s))
Theorem: Complex.arg_coe_angle_toReal_eq_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [Real.Angle.toReal_coe_eq_self_iff_mem_Ioc]
state_before: z : ℂ
⊢ Angle.toReal ↑(arg z) = arg z

tactic: exact arg_mem_Ioc _
state_before: z : ℂ
⊢ arg z ∈ Set.Ioc (-π) π
Theorem: MeasureTheory.ae_restrict_of_ae_eq_of_ae_restrict
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [Measure.restrict_congr_set hst]
state_before: α : Type u_1
β : Type ?u.589734
γ : Type ?u.589737
δ : Type ?u.589740
ι : Type ?u.589743
R : Type ?u.589746
R' : Type ?u.589749
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
s t : α → Prop
hst : s =ᶠ[ae μ] t
p : α → Prop
⊢ (∀ᵐ (x : α) ∂Measure.restrict μ s, p x) → ∀ᵐ (x : α) ∂Measure.restrict μ t, p x
Theorem: TopCat.openEmbedding_of_pullback_open_embeddings
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: convert H₂.comp (snd_openEmbedding_of_left_openEmbedding H₁ g)
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : OpenEmbedding ((forget TopCat).map f)
H₂ : OpenEmbedding ((forget TopCat).map g)
⊢ OpenEmbedding ((forget TopCat).map (limit.π (cospan f g) WalkingCospan.one))

tactic: erw [← coe_comp]
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : OpenEmbedding ((forget TopCat).map f)
H₂ : OpenEmbedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj ((cospan f g).obj WalkingCospan.one) = (forget TopCat).obj S
⊢ (forget TopCat).map (limit.π (cospan f g) WalkingCospan.one) =
    (forget TopCat).map g ∘ (forget TopCat).map pullback.snd

tactic: congr
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : OpenEmbedding ((forget TopCat).map f)
H₂ : OpenEmbedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj ((cospan f g).obj WalkingCospan.one) = (forget TopCat).obj S
⊢ (forget TopCat).map (limit.π (cospan f g) WalkingCospan.one) = (forget TopCat).map (pullback.snd ≫ g)

tactic: exact (limit.w _ WalkingCospan.Hom.inr).symm
state_before: case h.e'_5.h.e_a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : OpenEmbedding ((forget TopCat).map f)
H₂ : OpenEmbedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj ((cospan f g).obj WalkingCospan.one) = (forget TopCat).obj S
⊢ limit.π (cospan f g) WalkingCospan.one = pullback.snd ≫ g
Theorem: integral_cos_pow_three
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: have := @integral_sin_pow_mul_cos_pow_odd a b 0 1
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, cos x ^ 3) = sin b - sin a - (sin b ^ 3 - sin a ^ 3) / 3

tactic: norm_num at this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, sin x ^ 0 * cos x ^ (2 * 1 + 1)) = ∫ (u : ℝ) in sin a..sin b, u ^ 0 * (1 - u ^ 2) ^ 1
⊢ (∫ (x : ℝ) in a..b, cos x ^ 3) = sin b - sin a - (sin b ^ 3 - sin a ^ 3) / 3

tactic: exact this
state_before: a b : ℝ
n : ℕ
this : (∫ (x : ℝ) in a..b, cos x ^ 3) = sin b - sin a - (sin b ^ 3 - sin a ^ 3) / 3
⊢ (∫ (x : ℝ) in a..b, cos x ^ 3) = sin b - sin a - (sin b ^ 3 - sin a ^ 3) / 3
Theorem: AddSubmonoid.bot_mul
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rw [AddSubmonoid.mem_bot] at hm ⊢
state_before: α : Type ?u.250853
G : Type ?u.250856
M : Type ?u.250859
R : Type u_1
A : Type ?u.250865
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
S : AddSubmonoid R
m : R
hm : m ∈ ⊥
n : R
hn : n ∈ S
⊢ m * n ∈ ⊥

tactic: rw [hm, zero_mul]
state_before: α : Type ?u.250853
G : Type ?u.250856
M : Type ?u.250859
R : Type u_1
A : Type ?u.250865
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
S : AddSubmonoid R
m : R
hm : m = 0
n : R
hn : n ∈ S
⊢ m * n = 0
Theorem: Set.Ioc_diff_Iic
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [diff_eq, compl_Iic, Ioc_inter_Ioi, sup_eq_max]
state_before: α : Type u_1
β : Type ?u.210763
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b \ Iic c = Ioc (max a c) b
Theorem: LinearMap.quotientInfEquivSupQuotient_symm_apply_left
File: Mathlib/LinearAlgebra/Isomorphisms.lean

tactic: rw [quotientInfEquivSupQuotient_apply_mk, ofLe_apply]
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.100895
M₃ : Type ?u.100898
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x : { x // x ∈ p ⊔ p' }
hx : ↑x ∈ p
⊢ Submodule.Quotient.mk x = ↑(quotientInfEquivSupQuotient p p') (Submodule.Quotient.mk { val := ↑x, property := hx })
Theorem: LaurentPolynomial.support_C_mul_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [← single_eq_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
a : R
n : ℤ
⊢ (↑C a * T n).support ⊆ {n}

tactic: exact support_single_subset
state_before: R : Type u_1
inst✝ : Semiring R
a : R
n : ℤ
⊢ (Finsupp.single n a).support ⊆ {n}
Theorem: FreeRing.coe_sub
File: Mathlib/RingTheory/FreeCommRing.lean

tactic: rw [castFreeCommRing, map_sub]
state_before: α : Type u
x y : FreeRing α
⊢ ↑(x - y) = ↑x - ↑y
Theorem: inner_neg_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_neg_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1737773
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner x (-y) = -inner x y

tactic: simp only [RingHom.map_neg, inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1737773
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ ↑(starRingEnd 𝕜) (-inner y x) = -inner x y
Theorem: two_add_one_eq_three
File: Mathlib/Data/Nat/Cast/Defs.lean

tactic: rw [←one_add_one_eq_two, ←Nat.cast_one, ←Nat.cast_add, ←Nat.cast_add]
state_before: α : Type u_1
inst✝ : AddMonoidWithOne α
⊢ 2 + 1 = 3

tactic: apply congrArg
state_before: α : Type u_1
inst✝ : AddMonoidWithOne α
⊢ ↑(1 + 1 + 1) = 3

tactic: decide
state_before: case h
α : Type u_1
inst✝ : AddMonoidWithOne α
⊢ 1 + 1 + 1 = 3
Theorem: Nat.size_eq_bits_len
File: Mathlib/Data/Nat/Size.lean

tactic: induction' n using Nat.binaryRec' with b n h ih
state_before: n : ℕ
⊢ List.length (bits n) = size n

tactic: rw [size_bit, bits_append_bit _ _ h]
state_before: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : List.length (bits n) = size n
⊢ List.length (bits (bit b n)) = size (bit b n)

tactic: simp
state_before: case z

⊢ List.length (bits 0) = size 0

tactic: simp [ih]
state_before: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : List.length (bits n) = size n
⊢ List.length (b :: bits n) = succ (size n)

tactic: simpa [bit_eq_zero_iff]
state_before: case f
b : Bool
n : ℕ
h : n = 0 → b = true
ih : List.length (bits n) = size n
⊢ bit b n ≠ 0
Theorem: CategoryTheory.any_functor_const_on_obj
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: ext
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
α : Type u₁
F : J ⥤ Discrete α
j j' : J
⊢ F.obj j = F.obj j'

tactic: exact ((isoConstant F j').hom.app j).down.1
state_before: case as
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
α : Type u₁
F : J ⥤ Discrete α
j j' : J
⊢ (F.obj j).as = (F.obj j').as
Theorem: StrictConvexOn.add
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_add, add_add_add_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.296238
α : Type ?u.296241
β : Type u_3
ι : Type ?u.296247
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedCancelAddCommMonoid β
inst✝¹ : SMul 𝕜 E
inst✝ : DistribMulAction 𝕜 β
s : Set E
f g : E → β
hf : StrictConvexOn 𝕜 s f
hg : StrictConvexOn 𝕜 s g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • f x + b • f y + (a • g x + b • g y) = a • (f x + g x) + b • (f y + g y)
Theorem: Finset.disjoint_sup_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: simp only [disjoint_iff, sup_inf_distrib_left, Finset.sup_eq_bot_iff]
state_before: F : Type ?u.140859
α : Type u_1
β : Type ?u.140865
γ : Type ?u.140868
ι : Type u_2
κ : Type ?u.140874
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
s : Finset ι
t : Finset κ
f : ι → α
g : κ → α
a : α
⊢ _root_.Disjoint a (sup s f) ↔ ∀ ⦃i : ι⦄, i ∈ s → _root_.Disjoint a (f i)