tasksource/leandojo huggingface dataset:
Theorem: LinearMap.disjoint_ker'
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simp [h]
state_before: R : Type u_1
R₁ : Type ?u.1371370
R₂ : Type u_3
R₃ : Type ?u.1371376
R₄ : Type ?u.1371379
S : Type ?u.1371382
K : Type ?u.1371385
K₂ : Type ?u.1371388
M : Type u_2
M' : Type ?u.1371394
M₁ : Type ?u.1371397
M₂ : Type u_4
M₃ : Type ?u.1371403
M₄ : Type ?u.1371406
N : Type ?u.1371409
N₂ : Type ?u.1371412
ι : Type ?u.1371415
V : Type ?u.1371418
V₂ : Type ?u.1371421
inst✝⁹ : Ring R
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₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
f : F
p : Submodule R M
H : ∀ (x : M), x ∈ p → ↑f x = 0 → x = 0
x : M
hx : x ∈ p
y : M
hy : y ∈ p
h : ↑f x = ↑f y
⊢ ↑f (x - y) = 0

tactic: simpa using h₂
state_before: R : Type u_1
R₁ : Type ?u.1371370
R₂ : Type u_3
R₃ : Type ?u.1371376
R₄ : Type ?u.1371379
S : Type ?u.1371382
K : Type ?u.1371385
K₂ : Type ?u.1371388
M : Type u_2
M' : Type ?u.1371394
M₁ : Type ?u.1371397
M₂ : Type u_4
M₃ : Type ?u.1371403
M₄ : Type ?u.1371406
N : Type ?u.1371409
N₂ : Type ?u.1371412
ι : Type ?u.1371415
V : Type ?u.1371418
V₂ : Type ?u.1371421
inst✝⁹ : Ring R
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₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
f : F
p : Submodule R M
H : ∀ (x : M), x ∈ p → ∀ (y : M), y ∈ p → ↑f x = ↑f y → x = y
x : M
h₁ : x ∈ p
h₂ : ↑f x = 0
⊢ ↑f x = ↑f 0
Theorem: Ideal.exists_nonzero_mem_of_ne_bot
File: Mathlib/RingTheory/Ideal/Over.lean

tactic: obtain ⟨m, hm⟩ := Submodule.nonzero_mem_of_bot_lt (bot_lt_iff_ne_bot.mpr Pb)
state_before: R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.73967
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
Pb : P ≠ ⊥
hP : ∀ (x : R), ↑C x ∈ P → x = 0
⊢ ∃ p, p ∈ P ∧ Polynomial.map (Quotient.mk (comap C P)) p ≠ 0

tactic: refine' ⟨m, Submodule.coe_mem m, fun pp0 => hm (Submodule.coe_eq_zero.mp _)⟩
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.73967
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
Pb : P ≠ ⊥
hP : ∀ (x : R), ↑C x ∈ P → x = 0
m : { x // x ∈ P }
hm : m ≠ 0
⊢ ∃ p, p ∈ P ∧ Polynomial.map (Quotient.mk (comap C P)) p ≠ 0

tactic: refine'
  (injective_iff_map_eq_zero (Polynomial.mapRingHom (Ideal.Quotient.mk
    (P.comap (C : R →+* R[X]))))).mp
    _ _ pp0
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.73967
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
Pb : P ≠ ⊥
hP : ∀ (x : R), ↑C x ∈ P → x = 0
m : { x // x ∈ P }
hm : m ≠ 0
pp0 : Polynomial.map (Quotient.mk (comap C P)) ↑m = 0
⊢ ↑m = 0

tactic: refine' map_injective _ ((Ideal.Quotient.mk (P.comap C)).injective_iff_ker_eq_bot.mpr _)
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.73967
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
Pb : P ≠ ⊥
hP : ∀ (x : R), ↑C x ∈ P → x = 0
m : { x // x ∈ P }
hm : m ≠ 0
pp0 : Polynomial.map (Quotient.mk (comap C P)) ↑m = 0
⊢ Function.Injective ↑(mapRingHom (Quotient.mk (comap C P)))

tactic: rw [mk_ker]
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.73967
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
Pb : P ≠ ⊥
hP : ∀ (x : R), ↑C x ∈ P → x = 0
m : { x // x ∈ P }
hm : m ≠ 0
pp0 : Polynomial.map (Quotient.mk (comap C P)) ↑m = 0
⊢ RingHom.ker (Quotient.mk (comap C P)) = ⊥

tactic: exact (Submodule.eq_bot_iff _).mpr fun x hx => hP x (mem_comap.mp hx)
state_before: case intro
R : Type u_1
inst✝¹ : CommRing R
S : Type ?u.73967
inst✝ : CommRing S
f : R →+* S
I J : Ideal S
P : Ideal R[X]
Pb : P ≠ ⊥
hP : ∀ (x : R), ↑C x ∈ P → x = 0
m : { x // x ∈ P }
hm : m ≠ 0
pp0 : Polynomial.map (Quotient.mk (comap C P)) ↑m = 0
⊢ comap C P = ⊥
Theorem: Function.Periodic.nat_mul
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [nsmul_eq_mul] using h.nsmul n
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.96089
f g : α → β
c c₁ c₂ x : α
inst✝ : Semiring α
h : Periodic f c
n : ℕ
⊢ Periodic f (↑n * c)
Theorem: Set.sigmaToiUnion_injective
File: Mathlib/Data/Set/Lattice.lean

tactic: subst b_eq
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.300743
ι : Sort ?u.300746
ι' : Sort ?u.300749
ι₂ : Sort ?u.300752
κ : ι → Sort ?u.300757
κ₁ : ι → Sort ?u.300762
κ₂ : ι → Sort ?u.300767
κ' : ι' → Sort ?u.300772
t : α → Set β
h : ∀ (i j : α), i ≠ j → Disjoint (t i) (t j)
a₁ : α
b₁ : β
h₁ : b₁ ∈ t a₁
a₂ : α
b₂ : β
h₂ : b₂ ∈ t a₂
eq :
  sigmaToiUnion t { fst := a₁, snd := { val := b₁, property := h₁ } } =
    sigmaToiUnion t { fst := a₂, snd := { val := b₂, property := h₂ } }
b_eq : b₁ = b₂
a_eq : a₁ = a₂
⊢ ↑(Eq.recOn a_eq { fst := a₁, snd := { val := b₁, property := h₁ } }.snd) =
    ↑{ fst := a₂, snd := { val := b₂, property := h₂ } }.snd

tactic: subst a_eq
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.300743
ι : Sort ?u.300746
ι' : Sort ?u.300749
ι₂ : Sort ?u.300752
κ : ι → Sort ?u.300757
κ₁ : ι → Sort ?u.300762
κ₂ : ι → Sort ?u.300767
κ' : ι' → Sort ?u.300772
t : α → Set β
h : ∀ (i j : α), i ≠ j → Disjoint (t i) (t j)
a₁ : α
b₁ : β
h₁ : b₁ ∈ t a₁
a₂ : α
a_eq : a₁ = a₂
h₂ : b₁ ∈ t a₂
eq :
  sigmaToiUnion t { fst := a₁, snd := { val := b₁, property := h₁ } } =
    sigmaToiUnion t { fst := a₂, snd := { val := b₁, property := h₂ } }
⊢ ↑(Eq.recOn a_eq { fst := a₁, snd := { val := b₁, property := h₁ } }.snd) =
    ↑{ fst := a₂, snd := { val := b₁, property := h₂ } }.snd

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.300743
ι : Sort ?u.300746
ι' : Sort ?u.300749
ι₂ : Sort ?u.300752
κ : ι → Sort ?u.300757
κ₁ : ι → Sort ?u.300762
κ₂ : ι → Sort ?u.300767
κ' : ι' → Sort ?u.300772
t : α → Set β
h : ∀ (i j : α), i ≠ j → Disjoint (t i) (t j)
a₁ : α
b₁ : β
h₁ h₂ : b₁ ∈ t a₁
eq :
  sigmaToiUnion t { fst := a₁, snd := { val := b₁, property := h₁ } } =
    sigmaToiUnion t { fst := a₁, snd := { val := b₁, property := h₂ } }
⊢ ↑(Eq.recOn (_ : a₁ = a₁) { fst := a₁, snd := { val := b₁, property := h₁ } }.snd) =
    ↑{ fst := a₁, snd := { val := b₁, property := h₂ } }.snd
Theorem: Matrix.toBlock_diagonal_disjoint
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (⟨i, hi⟩⟨j, hj⟩)
state_before: l : Type ?u.115337
m : Type u_1
n : Type ?u.115343
o : Type ?u.115346
p✝ : Type ?u.115349
q✝ : Type ?u.115352
m' : o → Type ?u.115357
n' : o → Type ?u.115362
p' : o → Type ?u.115367
R : Type ?u.115370
S : Type ?u.115373
α : Type u_2
β : Type ?u.115379
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p q : m → Prop
hpq : Disjoint p q
⊢ toBlock (diagonal d) p q = 0

tactic: have : i ≠ j := fun heq => hpq.le_bot i ⟨hi, heq.symm ▸ hj⟩
state_before: case a.mk.h.mk
l : Type ?u.115337
m : Type u_1
n : Type ?u.115343
o : Type ?u.115346
p✝ : Type ?u.115349
q✝ : Type ?u.115352
m' : o → Type ?u.115357
n' : o → Type ?u.115362
p' : o → Type ?u.115367
R : Type ?u.115370
S : Type ?u.115373
α : Type u_2
β : Type ?u.115379
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p q : m → Prop
hpq : Disjoint p q
i : m
hi : p i
j : m
hj : q j
⊢ toBlock (diagonal d) p q { val := i, property := hi } { val := j, property := hj } =
    OfNat.ofNat 0 { val := i, property := hi } { val := j, property := hj }

tactic: simp [diagonal_apply_ne d this]
state_before: case a.mk.h.mk
l : Type ?u.115337
m : Type u_1
n : Type ?u.115343
o : Type ?u.115346
p✝ : Type ?u.115349
q✝ : Type ?u.115352
m' : o → Type ?u.115357
n' : o → Type ?u.115362
p' : o → Type ?u.115367
R : Type ?u.115370
S : Type ?u.115373
α : Type u_2
β : Type ?u.115379
inst✝² : DecidableEq l
inst✝¹ : DecidableEq m
inst✝ : Zero α
d : m → α
p q : m → Prop
hpq : Disjoint p q
i : m
hi : p i
j : m
hj : q j
this : i ≠ j
⊢ toBlock (diagonal d) p q { val := i, property := hi } { val := j, property := hj } =
    OfNat.ofNat 0 { val := i, property := hi } { val := j, property := hj }
Theorem: Primrec.pair
File: Mathlib/Computability/Primrec.lean

tactic: cases @decode α _ n <;> simp [encodek]
state_before: α✝ : Type ?u.47877
σ : Type ?u.47880
inst✝⁴ : Primcodable α✝
inst✝³ : Primcodable σ
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
f : α → β
g : α → γ
hf : Primrec f
hg : Primrec g
n : ℕ
⊢ (Nat.casesOn (encode (decode n)) 0 fun n =>
      Nat.succ (Nat.pair (Nat.pred (encode (Option.map f (decode n)))) (Nat.pred (encode (Option.map g (decode n)))))) =
    encode (Option.map (fun a => (f a, g a)) (decode n))
Theorem: mem_closure_iff_frequently
File: Mathlib/Topology/Basic.lean

tactic: rw [Filter.Frequently, Filter.Eventually, ← mem_interior_iff_mem_nhds,
    closure_eq_compl_interior_compl]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
a : α
⊢ a ∈ closure s ↔ ∃ᶠ (x : α) in 𝓝 a, x ∈ s

tactic: rfl
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
a : α
⊢ a ∈ interior (sᶜ)ᶜ ↔ ¬a ∈ interior {x | ¬x ∈ s}
Theorem: Nat.measurable_floor
File: Mathlib/MeasureTheory/Function/Floor.lean

tactic: cases' eq_or_ne ⌊n⌋₊ 0 with h h <;> simp_all [h, Nat.preimage_floor_of_ne_zero]
state_before: α : Type ?u.6253
R : Type u_1
inst✝⁶ : MeasurableSpace α
inst✝⁵ : LinearOrderedSemiring R
inst✝⁴ : FloorSemiring R
inst✝³ : TopologicalSpace R
inst✝² : OrderTopology R
inst✝¹ : MeasurableSpace R
inst✝ : OpensMeasurableSpace R
f : α → R
n : R
⊢ MeasurableSet (floor ⁻¹' {⌊n⌋₊})
Theorem: PFun.mem_dom
File: Mathlib/Data/PFun.lean

tactic: simp [Dom, Part.dom_iff_mem]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.8010
δ : Type ?u.8013
ε : Type ?u.8016
ι : Type ?u.8019
f : α →. β
x : α
⊢ x ∈ Dom f ↔ ∃ y, y ∈ f x
Theorem: Nat.div2_bits_eq_tail
File: Mathlib/Data/Nat/Bits.lean

tactic: induction' n using Nat.binaryRec' with b n h _
state_before: n✝ n : ℕ
⊢ bits (div2 n) = List.tail (bits n)

tactic: simp [div2_bit, bits_append_bit _ _ h]
state_before: case f
n✝ : ℕ
b : Bool
n : ℕ
h : n = 0 → b = true
a✝ : bits (div2 n) = List.tail (bits n)
⊢ bits (div2 (bit b n)) = List.tail (bits (bit b n))

tactic: simp
state_before: case z
n : ℕ
⊢ bits (div2 0) = List.tail (bits 0)
Theorem: Ordinal.IsFundamentalSequence.monotone
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rcases lt_or_eq_of_le hij with (hij | rfl)
state_before: α : Type ?u.69712
r : α → α → Prop
a o : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
i j : Ordinal
hi : i < o
hj : j < o
hij : i ≤ j
⊢ f i hi ≤ f j hj

tactic: exact (hf.2.1 hi hj hij).le
state_before: case inl
α : Type ?u.69712
r : α → α → Prop
a o : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
i j : Ordinal
hi : i < o
hj : j < o
hij✝ : i ≤ j
hij : i < j
⊢ f i hi ≤ f j hj

tactic: rfl
state_before: case inr
α : Type ?u.69712
r : α → α → Prop
a o : Ordinal
f : (b : Ordinal) → b < o → Ordinal
hf : IsFundamentalSequence a o f
i : Ordinal
hi hj : i < o
hij : i ≤ i
⊢ f i hi ≤ f i hj
Theorem: Num.cmp_swap
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases m <;> cases n <;> try { unfold cmp } <;> try { rfl }
state_before: α : Type ?u.468320
m n : Num
⊢ Ordering.swap (cmp m n) = cmp n m

tactic: apply PosNum.cmp_swap
state_before: case pos.pos
α : Type ?u.468320
a✝¹ a✝ : PosNum
⊢ Ordering.swap (cmp (pos a✝¹) (pos a✝)) = cmp (pos a✝) (pos a✝¹)
Theorem: LinearPMap.ext
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: rcases f with ⟨f_dom, f⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.20860
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : f.domain = g.domain
h' : ∀ ⦃x : { x // x ∈ f.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄, ↑x = ↑y → ↑f x = ↑g y
⊢ f = g

tactic: rcases g with ⟨g_dom, g⟩
state_before: case mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.20860
inst✝¹ : AddCommGroup G
inst✝ : Module R G
g : E →ₗ.[R] F
f_dom : Submodule R E
f : { x // x ∈ f_dom } →ₗ[R] F
h : { domain := f_dom, toFun := f }.domain = g.domain
h' :
  ∀ ⦃x : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄ ⦃y : { x // x ∈ g.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑g y
⊢ { domain := f_dom, toFun := f } = g

tactic: obtain rfl : f_dom = g_dom := h
state_before: case mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.20860
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f_dom : Submodule R E
f : { x // x ∈ f_dom } →ₗ[R] F
g_dom : Submodule R E
g : { x // x ∈ g_dom } →ₗ[R] F
h : { domain := f_dom, toFun := f }.domain = { domain := g_dom, toFun := g }.domain
h' :
  ∀ ⦃x : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄ ⦃y : { x // x ∈ { domain := g_dom, toFun := g }.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑{ domain := g_dom, toFun := g } y
⊢ { domain := f_dom, toFun := f } = { domain := g_dom, toFun := g }

tactic: obtain rfl : f = g := LinearMap.ext fun x => h' rfl
state_before: case mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.20860
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f_dom : Submodule R E
f g : { x // x ∈ f_dom } →ₗ[R] F
h' :
  ∀ ⦃x : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄ ⦃y : { x // x ∈ { domain := f_dom, toFun := g }.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑{ domain := f_dom, toFun := g } y
⊢ { domain := f_dom, toFun := f } = { domain := f_dom, toFun := g }

tactic: rfl
state_before: case mk.mk
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.20860
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f_dom : Submodule R E
f : { x // x ∈ f_dom } →ₗ[R] F
h' :
  ∀ ⦃x y : { x // x ∈ { domain := f_dom, toFun := f }.domain }⦄,
    ↑x = ↑y → ↑{ domain := f_dom, toFun := f } x = ↑{ domain := f_dom, toFun := f } y
⊢ { domain := f_dom, toFun := f } = { domain := f_dom, toFun := f }
Theorem: CategoryTheory.IsPullback.of_isBilimit
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: convert IsPullback.of_is_product' h.isLimit HasZeroObject.zeroIsTerminal
state_before: C : Type u₁
inst✝² : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : BinaryBicone.IsBilimit b
⊢ IsPullback b.fst b.snd 0 0
Theorem: Finset.prod_subtype_map_embedding
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Finset.prod_map]
state_before: ι : Type ?u.382203
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
s : Finset { x // p x }
f : { x // p x } → β
g : α → β
h : ∀ (x : { x // p x }), x ∈ s → g ↑x = f x
⊢ ∏ x in map (Function.Embedding.subtype fun x => p x) s, g x = ∏ x in s, f x

tactic: exact Finset.prod_congr rfl h
state_before: ι : Type ?u.382203
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝ : CommMonoid β
p : α → Prop
s : Finset { x // p x }
f : { x // p x } → β
g : α → β
h : ∀ (x : { x // p x }), x ∈ s → g ↑x = f x
⊢ ∏ x in s, g (↑(Function.Embedding.subtype fun x => p x) x) = ∏ x in s, f x
Theorem: integral_sin_mul_cos₁
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simpa using integral_sin_pow_mul_cos_pow_odd 1 0
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, sin x * cos x) = (sin b ^ 2 - sin a ^ 2) / 2
Theorem: CategoryTheory.Subobject.prod_eq_inf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: apply le_antisymm
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) = f₁ ⊓ f₂

tactic: . refine' le_inf _ _ _ (Limits.prod.fst.le) (Limits.prod.snd.le)
state_before: case a
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) ≤ f₁ ⊓ f₂

case a
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ≤ (f₁ ⨯ f₂)

tactic: . apply leOfHom
  exact prod.lift (inf_le_left _ _).hom (inf_le_right _ _).hom
state_before: case a
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ≤ (f₁ ⨯ f₂)

tactic: refine' le_inf _ _ _ (Limits.prod.fst.le) (Limits.prod.snd.le)
state_before: case a
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) ≤ f₁ ⊓ f₂

tactic: apply leOfHom
state_before: case a
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ≤ (f₁ ⨯ f₂)

tactic: exact prod.lift (inf_le_left _ _).hom (inf_le_right _ _).hom
state_before: case a.h
C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ⟶ f₁ ⨯ f₂
Theorem: Equiv.prod_assoc_symm_preimage
File: Mathlib/Logic/Equiv/Set.lean

tactic: ext
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ↑(prodAssoc α β γ).symm ⁻¹' (s ×ˢ t) ×ˢ u = s ×ˢ t ×ˢ u

tactic: simp [and_assoc]
state_before: case h
α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
x✝ : α × β × γ
⊢ x✝ ∈ ↑(prodAssoc α β γ).symm ⁻¹' (s ×ˢ t) ×ˢ u ↔ x✝ ∈ s ×ˢ t ×ˢ u
Theorem: IsSMulRegular.mul_iff
File: Mathlib/Algebra/Regular/SMul.lean

tactic: rw [← mul_and_mul_iff]
state_before: R : Type u_1
S : Type ?u.29294
M : Type u_2
a b : R
s : S
inst✝² : CommSemigroup R
inst✝¹ : SMul R M
inst✝ : IsScalarTower R R M
⊢ IsSMulRegular M (a * b) ↔ IsSMulRegular M a ∧ IsSMulRegular M b

tactic: exact ⟨fun ab => ⟨ab, by rwa [mul_comm]⟩, fun rab => rab.1⟩
state_before: R : Type u_1
S : Type ?u.29294
M : Type u_2
a b : R
s : S
inst✝² : CommSemigroup R
inst✝¹ : SMul R M
inst✝ : IsScalarTower R R M
⊢ IsSMulRegular M (a * b) ↔ IsSMulRegular M (a * b) ∧ IsSMulRegular M (b * a)

tactic: rwa [mul_comm]
state_before: R : Type u_1
S : Type ?u.29294
M : Type u_2
a b : R
s : S
inst✝² : CommSemigroup R
inst✝¹ : SMul R M
inst✝ : IsScalarTower R R M
ab : IsSMulRegular M (a * b)
⊢ IsSMulRegular M (b * a)
Theorem: Algebra.FinitePresentation.mvPolynomial
File: Mathlib/RingTheory/FinitePresentation.lean

tactic: cases nonempty_fintype ι
state_before: R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
ι : Type u_2
inst✝ : Finite ι
⊢ FinitePresentation R (MvPolynomial ι R)

tactic: let eqv := (MvPolynomial.renameEquiv R <| Fintype.equivFin ι).symm
state_before: case intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
ι : Type u_2
inst✝ : Finite ι
val✝ : Fintype ι
⊢ FinitePresentation R (MvPolynomial ι R)

tactic: exact
  ⟨Fintype.card ι, eqv, eqv.surjective,
    ((RingHom.injective_iff_ker_eq_bot _).1 eqv.injective).symm ▸ Submodule.fg_bot⟩
state_before: case intro
R : Type w₁
A : Type w₂
B : Type w₃
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Algebra R A
inst✝² : CommRing B
inst✝¹ : Algebra R B
ι : Type u_2
inst✝ : Finite ι
val✝ : Fintype ι
eqv : MvPolynomial (Fin (Fintype.card ι)) R ≃ₐ[R] MvPolynomial ι R :=
  AlgEquiv.symm (MvPolynomial.renameEquiv R (Fintype.equivFin ι))
⊢ FinitePresentation R (MvPolynomial ι R)
Theorem: Homeomorph.comp_continuousAt_iff'
File: Mathlib/Topology/Homeomorph.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.71605
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
h : α ≃ₜ β
f : β → γ
x : α
⊢ range ↑h ∈ 𝓝 (↑h x)
Theorem: AffineBasis.coord_apply_centroid
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: rw [Finset.centroid,
  b.coord_apply_combination_of_mem hi (s.sum_centroidWeights_eq_one_of_nonempty _ ⟨i, hi⟩),
  Finset.centroidWeights, Function.const_apply]
state_before: ι : Type u_2
ι' : Type ?u.181001
k : Type u_1
V : Type u_3
P : Type u_4
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : DivisionRing k
inst✝¹ : Module k V
inst✝ : CharZero k
b : AffineBasis ι k P
s : Finset ι
i : ι
hi : i ∈ s
⊢ ↑(coord b i) (Finset.centroid k s ↑b) = (↑(Finset.card s))⁻¹
Theorem: Real.Angle.sin_eq_real_sin_iff_eq_or_add_eq_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
ψ : ℝ
⊢ sin θ = Real.sin ψ ↔ θ = ↑ψ ∨ θ + ↑ψ = ↑π

tactic: exact sin_eq_iff_coe_eq_or_add_eq_pi
state_before: case h
ψ x✝ : ℝ
⊢ sin ↑x✝ = Real.sin ψ ↔ ↑x✝ = ↑ψ ∨ ↑x✝ + ↑ψ = ↑π
Theorem: isPreconnected_iff_preconnectedSpace
File: Mathlib/Topology/Connected.lean

tactic: simpa using isPreconnected_univ.image ((↑) : s → α) continuous_subtype_val.continuousOn
state_before: α : Type u
β : Type v
ι : Type ?u.72105
π : ι → Type ?u.72110
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
h : PreconnectedSpace ↑s
⊢ IsPreconnected s
Theorem: norm_algebraMap'
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [norm_algebraMap, norm_one, mul_one]
state_before: α : Type ?u.480957
β : Type ?u.480960
γ : Type ?u.480963
ι : Type ?u.480966
𝕜 : Type u_2
𝕜' : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedRing 𝕜'
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormOneClass 𝕜'
x : 𝕜
⊢ ‖↑(algebraMap 𝕜 𝕜') x‖ = ‖x‖
Theorem: Nat.gcd_add_self_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [one_mul]
state_before: m n : ℕ
⊢ gcd m (n + m) = gcd m (n + 1 * m)
Theorem: Nat.choose_zero_right
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: cases n <;> rfl
state_before: n : ℕ
⊢ choose n 0 = 1
Theorem: Submodule.mem_iSup_iff_exists_dfinsupp'
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: rw [mem_iSup_iff_exists_dfinsupp]
state_before: ι : Type u_3
R : Type u_1
S : Type ?u.436512
M : ι → Type ?u.436517
N : Type u_2
dec_ι : DecidableEq ι
inst✝³ : Semiring R
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
p : ι → Submodule R N
inst✝ : (i : ι) → (x : { x // x ∈ p i }) → Decidable (x ≠ 0)
x : N
⊢ x ∈ iSup p ↔ ∃ f, (sum f fun i xi => ↑xi) = x

tactic: simp_rw [Dfinsupp.lsum_apply_apply, Dfinsupp.sumAddHom_apply,
  LinearMap.toAddMonoidHom_coe, coeSubtype]
state_before: ι : Type u_3
R : Type u_1
S : Type ?u.436512
M : ι → Type ?u.436517
N : Type u_2
dec_ι : DecidableEq ι
inst✝³ : Semiring R
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
p : ι → Submodule R N
inst✝ : (i : ι) → (x : { x // x ∈ p i }) → Decidable (x ≠ 0)
x : N
⊢ (∃ f, ↑(↑(lsum ℕ) fun i => Submodule.subtype (p i)) f = x) ↔ ∃ f, (sum f fun i xi => ↑xi) = x
Theorem: Finset.disjoint_or_nonempty_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← not_disjoint_iff_nonempty_inter]
state_before: α : Type u_1
β : Type ?u.203129
γ : Type ?u.203132
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
s t : Finset α
⊢ _root_.Disjoint s t ∨ Finset.Nonempty (s ∩ t)

tactic: exact em _
state_before: α : Type u_1
β : Type ?u.203129
γ : Type ?u.203132
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
s t : Finset α
⊢ _root_.Disjoint s t ∨ ¬_root_.Disjoint s t
Theorem: Ordinal.bfamilyOfFamily'_typein
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp only [bfamilyOfFamily', enum_typein]
state_before: α : Type u_2
β : Type ?u.271133
γ : Type ?u.271136
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u_1
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
i : ι
⊢ bfamilyOfFamily' r f (typein r i) (_ : typein r i < type r) = f i