ul Top Colorado Republican Pressures Official to Report False Election Results By feeds.drudge.com Published On :: Sat, 09 May 2020 11:33:22 -0400 U.S. Rep. Ken Buck, who is also the chairman of the Colorado Republican Party, was captured ordering a local party official to report false election results in a primary race for a state Senate seat in a leaked audio recording released earlier this week. Full Article news
ul The Soulful Art of Persuasion with Jason Harris By feedproxy.google.com Published On :: Wed, 11 Sep 2019 13:00:42 +0000 As creators and entrepreneurs, getting our ideas out in the world is critical. And today, I have my long time friend Jason Harris in the hot seat to help us with just that. Jason is the founder and CEO of the award winning creative agency Mekanism. He is one of Creativity Mag’s most creative people in business, Top 100 People Who Make Advertising Great and about 52 other awards in the creative space. You’ve certainly seen his work if you’ve watched Superbowl commercials or heard of Peloton, Ben & Jerrys, HBO, and more. He also is one of the people that I look up to as a model of giving back. He donates a huge amount of his time to causes in which he believes and uses his marketing savvy for doing good in the world. I’m super inspired by our conversation today for so many reasons, but here’s handful to whet your palette: Of course we get into his new book The Soulful Art of Persuasion, in which Jason breaks down the art of sharing our ideas in an honest and authentic ways We talk about the ups and downs living life identifying as a professional creator, including the […] The post The Soulful Art of Persuasion with Jason Harris appeared first on Chase Jarvis Photography. Full Article chasejarvisLIVE Podcast ad agency Jason Harris Mekanism
ul Concurrency & Multithreading in iOS By feedproxy.google.com Published On :: Tue, 25 Feb 2020 08:00:00 -0500 Concurrency is the notion of multiple things happening at the same time. This is generally achieved either via time-slicing, or truly in parallel if multiple CPU cores are available to the host operating system. We've all experienced a lack of concurrency, most likely in the form of an app freezing up when running a heavy task. UI freezes don't necessarily occur due to the absence of concurrency — they could just be symptoms of buggy software — but software that doesn't take advantage of all the computational power at its disposal is going to create these freezes whenever it needs to do something resource-intensive. If you've profiled an app hanging in this way, you'll probably see a report that looks like this: Anything related to file I/O, data processing, or networking usually warrants a background task (unless you have a very compelling excuse to halt the entire program). There aren't many reasons that these tasks should block your user from interacting with the rest of your application. Consider how much better the user experience of your app could be if instead, the profiler reported something like this: Analyzing an image, processing a document or a piece of audio, or writing a sizeable chunk of data to disk are examples of tasks that could benefit greatly from being delegated to background threads. Let's dig into how we can enforce such behavior into our iOS applications. A Brief History In the olden days, the maximum amount of work per CPU cycle that a computer could perform was determined by the clock speed. As processor designs became more compact, heat and physical constraints started becoming limiting factors for higher clock speeds. Consequentially, chip manufacturers started adding additional processor cores on each chip in order to increase total performance. By increasing the number of cores, a single chip could execute more CPU instructions per cycle without increasing its speed, size, or thermal output. There's just one problem... How can we take advantage of these extra cores? Multithreading. Multithreading is an implementation handled by the host operating system to allow the creation and usage of n amount of threads. Its main purpose is to provide simultaneous execution of two or more parts of a program to utilize all available CPU time. Multithreading is a powerful technique to have in a programmer's toolbelt, but it comes with its own set of responsibilities. A common misconception is that multithreading requires a multi-core processor, but this isn't the case — single-core CPUs are perfectly capable of working on many threads, but we'll take a look in a bit as to why threading is a problem in the first place. Before we dive in, let's look at the nuances of what concurrency and parallelism mean using a simple diagram: In the first situation presented above, we observe that tasks can run concurrently, but not in parallel. This is similar to having multiple conversations in a chatroom, and interleaving (context-switching) between them, but never truly conversing with two people at the same time. This is what we call concurrency. It is the illusion of multiple things happening at the same time when in reality, they're switching very quickly. Concurrency is about dealing with lots of things at the same time. Contrast this with the parallelism model, in which both tasks run simultaneously. Both execution models exhibit multithreading, which is the involvement of multiple threads working towards one common goal. Multithreading is a generalized technique for introducing a combination of concurrency and parallelism into your program. The Burden of Threads A modern multitasking operating system like iOS has hundreds of programs (or processes) running at any given moment. However, most of these programs are either system daemons or background processes that have very low memory footprint, so what is really needed is a way for individual applications to make use of the extra cores available. An application (process) can have many threads (sub-processes) operating on shared memory. Our goal is to be able to control these threads and use them to our advantage. Historically, introducing concurrency to an app has required the creation of one or more threads. Threads are low-level constructs that need to be managed manually. A quick skim through Apple's Threaded Programming Guide is all it takes to see how much complexity threaded code adds to a codebase. In addition to building an app, the developer has to: Responsibly create new threads, adjusting that number dynamically as system conditions change Manage them carefully, deallocating them from memory once they have finished executing Leverage synchronization mechanisms like mutexes, locks, and semaphores to orchestrate resource access between threads, adding even more overhead to application code Mitigate risks associated with coding an application that assumes most of the costs associated with creating and maintaining any threads it uses, and not the host OS This is unfortunate, as it adds enormous levels of complexity and risk without any guarantees of improved performance. Grand Central Dispatch iOS takes an asynchronous approach to solving the concurrency problem of managing threads. Asynchronous functions are common in most programming environments, and are often used to initiate tasks that might take a long time, like reading a file from the disk, or downloading a file from the web. When invoked, an asynchronous function executes some work behind the scenes to start a background task, but returns immediately, regardless of how long the original task might takes to actually complete. A core technology that iOS provides for starting tasks asynchronously is Grand Central Dispatch (or GCD for short). GCD abstracts away thread management code and moves it down to the system level, exposing a light API to define tasks and execute them on an appropriate dispatch queue. GCD takes care of all thread management and scheduling, providing a holistic approach to task management and execution, while also providing better efficiency than traditional threads. Let's take a look at the main components of GCD: What've we got here? Let's start from the left: DispatchQueue.main: The main thread, or the UI thread, is backed by a single serial queue. All tasks are executed in succession, so it is guaranteed that the order of execution is preserved. It is crucial that you ensure all UI updates are designated to this queue, and that you never run any blocking tasks on it. We want to ensure that the app's run loop (called CFRunLoop) is never blocked in order to maintain the highest framerate. Subsequently, the main queue has the highest priority, and any tasks pushed onto this queue will get executed immediately. DispatchQueue.global: A set of global concurrent queues, each of which manage their own pool of threads. Depending on the priority of your task, you can specify which specific queue to execute your task on, although you should resort to using default most of the time. Because tasks on these queues are executed concurrently, it doesn't guarantee preservation of the order in which tasks were queued. Notice how we're not dealing with individual threads anymore? We're dealing with queues which manage a pool of threads internally, and you will shortly see why queues are a much more sustainable approach to multhreading. Serial Queues: The Main Thread As an exercise, let's look at a snippet of code below, which gets fired when the user presses a button in the app. The expensive compute function can be anything. Let's pretend it is post-processing an image stored on the device. import UIKit class ViewController: UIViewController { @IBAction func handleTap(_ sender: Any) { compute() } private func compute() -> Void { // Pretending to post-process a large image. var counter = 0 for _ in 0..<9999999 { counter += 1 } } } At first glance, this may look harmless, but if you run this inside of a real app, the UI will freeze completely until the loop is terminated, which will take... a while. We can prove it by profiling this task in Instruments. You can fire up the Time Profiler module of Instruments by going to Xcode > Open Developer Tool > Instruments in Xcode's menu options. Let's look at the Threads module of the profiler and see where the CPU usage is highest. We can see that the Main Thread is clearly at 100% capacity for almost 5 seconds. That's a non-trivial amount of time to block the UI. Looking at the call tree below the chart, we can see that the Main Thread is at 99.9% capacity for 4.43 seconds! Given that a serial queue works in a FIFO manner, tasks will always complete in the order in which they were inserted. Clearly the compute() method is the culprit here. Can you imagine clicking a button just to have the UI freeze up on you for that long? Background Threads How can we make this better? DispatchQueue.global() to the rescue! This is where background threads come in. Referring to the GCD architecture diagram above, we can see that anything that is not the Main Thread is a background thread in iOS. They can run alongside the Main Thread, leaving it fully unoccupied and ready to handle other UI events like scrolling, responding to user events, animating etc. Let's make a small change to our button click handler above: class ViewController: UIViewController { @IBAction func handleTap(_ sender: Any) { DispatchQueue.global(qos: .userInitiated).async { [unowned self] in self.compute() } } private func compute() -> Void { // Pretending to post-process a large image. var counter = 0 for _ in 0..<9999999 { counter += 1 } } } Unless specified, a snippet of code will usually default to execute on the Main Queue, so in order to force it to execute on a different thread, we'll wrap our compute call inside of an asynchronous closure that gets submitted to the DispatchQueue.global queue. Keep in mind that we aren't really managing threads here. We're submitting tasks (in the form of closures or blocks) to the desired queue with the assumption that it is guaranteed to execute at some point in time. The queue decides which thread to allocate the task to, and it does all the hard work of assessing system requirements and managing the actual threads. This is the magic of Grand Central Dispatch. As the old adage goes, you can't improve what you can't measure. So we measured our truly terrible button click handler, and now that we've improved it, we'll measure it once again to get some concrete data with regards to performance. Looking at the profiler again, it's quite clear to us that this is a huge improvement. The task takes an identical amount of time, but this time, it's happening in the background without locking up the UI. Even though our app is doing the same amount of work, the perceived performance is much better because the user will be free to do other things while the app is processing. You may have noticed that we accessed a global queue of .userInitiated priority. This is an attribute we can use to give our tasks a sense of urgency. If we run the same task on a global queue of and pass it a qos attribute of background , iOS will think it's a utility task, and thus allocate fewer resources to execute it. So, while we don't have control over when our tasks get executed, we do have control over their priority. A Note on Main Thread vs. Main Queue You might be wondering why the Profiler shows "Main Thread" and why we're referring to it as the "Main Queue". If you refer back to the GCD architecture we described above, the Main Queue is solely responsible for managing the Main Thread. The Dispatch Queues section in the Concurrency Programming Guide says that "the main dispatch queue is a globally available serial queue that executes tasks on the application’s main thread. Because it runs on your application’s main thread, the main queue is often used as a key synchronization point for an application." The terms "execute on the Main Thread" and "execute on the Main Queue" can be used interchangeably. Concurrent Queues So far, our tasks have been executed exclusively in a serial manner. DispatchQueue.main is by default a serial queue, and DispatchQueue.global gives you four concurrent dispatch queues depending on the priority parameter you pass in. Let's say we want to take five images, and have our app process them all in parallel on background threads. How would we go about doing that? We can spin up a custom concurrent queue with an identifier of our choosing, and allocate those tasks there. All that's required is the .concurrent attribute during the construction of the queue. class ViewController: UIViewController { let queue = DispatchQueue(label: "com.app.concurrentQueue", attributes: .concurrent) let images: [UIImage] = [UIImage].init(repeating: UIImage(), count: 5) @IBAction func handleTap(_ sender: Any) { for img in images { queue.async { [unowned self] in self.compute(img) } } } private func compute(_ img: UIImage) -> Void { // Pretending to post-process a large image. var counter = 0 for _ in 0..<9999999 { counter += 1 } } } Running that through the profiler, we can see that the app is now spinning up 5 discrete threads to parallelize a for-loop. Parallelization of N Tasks So far, we've looked at pushing computationally expensive task(s) onto background threads without clogging up the UI thread. But what about executing parallel tasks with some restrictions? How can Spotify download multiple songs in parallel, while limiting the maximum number up to 3? We can go about this in a few ways, but this is a good time to explore another important construct in multithreaded programming: semaphores. Semaphores are signaling mechanisms. They are commonly used to control access to a shared resource. Imagine a scenario where a thread can lock access to a certain section of the code while it executes it, and unlocks after it's done to let other threads execute the said section of the code. You would see this type of behavior in database writes and reads, for example. What if you want only one thread writing to a database and preventing any reads during that time? This is a common concern in thread-safety called Readers-writer lock. Semaphores can be used to control concurrency in our app by allowing us to lock n number of threads. let kMaxConcurrent = 3 // Or 1 if you want strictly ordered downloads! let semaphore = DispatchSemaphore(value: kMaxConcurrent) let downloadQueue = DispatchQueue(label: "com.app.downloadQueue", attributes: .concurrent) class ViewController: UIViewController { @IBAction func handleTap(_ sender: Any) { for i in 0..<15 { downloadQueue.async { [unowned self] in // Lock shared resource access semaphore.wait() // Expensive task self.download(i + 1) // Update the UI on the main thread, always! DispatchQueue.main.async { tableView.reloadData() // Release the lock semaphore.signal() } } } } func download(_ songId: Int) -> Void { var counter = 0 // Simulate semi-random download times. for _ in 0..<Int.random(in: 999999...10000000) { counter += songId } } } Notice how we've effectively restricted our download system to limit itself to k number of downloads. The moment one download finishes (or thread is done executing), it decrements the semaphore, allowing the managing queue to spawn another thread and start downloading another song. You can apply a similar pattern to database transactions when dealing with concurrent reads and writes. Semaphores usually aren't necessary for code like the one in our example, but they become more powerful when you need to enforce synchronous behavior whille consuming an asynchronous API. The above could would work just as well with a custom NSOperationQueue with a maxConcurrentOperationCount, but it's a worthwhile tangent regardless. Finer Control with OperationQueue GCD is great when you want to dispatch one-off tasks or closures into a queue in a 'set-it-and-forget-it' fashion, and it provides a very lightweight way of doing so. But what if we want to create a repeatable, structured, long-running task that produces associated state or data? And what if we want to model this chain of operations such that they can be cancelled, suspended and tracked, while still working with a closure-friendly API? Imagine an operation like this: This would be quite cumbersome to achieve with GCD. We want a more modular way of defining a group of tasks while maintaining readability and also exposing a greater amount of control. In this case, we can use Operation objects and queue them onto an OperationQueue, which is a high-level wrapper around DispatchQueue. Let's look at some of the benefits of using these abstractions and what they offer in comparison to the lower-level GCI API: You may want to create dependencies between tasks, and while you could do this via GCD, you're better off defining them concretely as Operation objects, or units of work, and pushing them onto your own queue. This would allow for maximum reusability since you may use the same pattern elsewhere in an application. The Operation and OperationQueue classes have a number of properties that can be observed, using KVO (Key Value Observing). This is another important benefit if you want to monitor the state of an operation or operation queue. Operations can be paused, resumed, and cancelled. Once you dispatch a task using Grand Central Dispatch, you no longer have control or insight into the execution of that task. The Operation API is more flexible in that respect, giving the developer control over the operation's life cycle. OperationQueue allows you to specify the maximum number of queued operations that can run simultaneously, giving you a finer degree of control over the concurrency aspects. The usage of Operation and OperationQueue could fill an entire blog post, but let's look at a quick example of what modeling dependencies looks like. (GCD can also create dependencies, but you're better off dividing up large tasks into a series of composable sub-tasks.) In order to create a chain of operations that depend on one another, we could do something like this: class ViewController: UIViewController { var queue = OperationQueue() var rawImage = UIImage? = nil let imageUrl = URL(string: "https://example.com/portrait.jpg")! @IBOutlet weak var imageView: UIImageView! let downloadOperation = BlockOperation { let image = Downloader.downloadImageWithURL(url: imageUrl) OperationQueue.main.async { self.rawImage = image } } let filterOperation = BlockOperation { let filteredImage = ImgProcessor.addGaussianBlur(self.rawImage) OperationQueue.main.async { self.imageView = filteredImage } } filterOperation.addDependency(downloadOperation) [downloadOperation, filterOperation].forEach { queue.addOperation($0) } } So why not opt for a higher level abstraction and avoid using GCD entirely? While GCD is ideal for inline asynchronous processing, Operation provides a more comprehensive, object-oriented model of computation for encapsulating all of the data around structured, repeatable tasks in an application. Developers should use the highest level of abstraction possible for any given problem, and for scheduling consistent, repeated work, that abstraction is Operation. Other times, it makes more sense to sprinkle in some GCD for one-off tasks or closures that we want to fire. We can mix both OperationQueue and GCD to get the best of both worlds. The Cost of Concurrency DispatchQueue and friends are meant to make it easier for the application developer to execute code concurrently. However, these technologies do not guarantee improvements to the efficiency or responsiveness in an application. It is up to you to use queues in a manner that is both effective and does not impose an undue burden on other resources. For example, it's totally viable to create 10,000 tasks and submit them to a queue, but doing so would allocate a nontrivial amount of memory and introduce a lot of overhead for the allocation and deallocation of operation blocks. This is the opposite of what you want! It's best to profile your app thoroughly to ensure that concurrency is enhancing your app's performance and not degrading it. We've talked about how concurrency comes at a cost in terms of complexity and allocation of system resources, but introducing concurrency also brings a host of other risks like: Deadlock: A situation where a thread locks a critical portion of the code and can halt the application's run loop entirely. In the context of GCD, you should be very careful when using the dispatchQueue.sync { } calls as you could easily get yourself in situations where two synchronous operations can get stuck waiting for each other. Priority Inversion: A condition where a lower priority task blocks a high priority task from executing, which effectively inverts their priorities. GCD allows for different levels of priority on its background queues, so this is quite easily a possibility. Producer-Consumer Problem: A race condition where one thread is creating a data resource while another thread is accessing it. This is a synchronization problem, and can be solved using locks, semaphores, serial queues, or a barrier dispatch if you're using concurrent queues in GCD. ...and many other sorts of locking and data-race conditions that are hard to debug! Thread safety is of the utmost concern when dealing with concurrency. Parting Thoughts + Further Reading If you've made it this far, I applaud you. Hopefully this article gives you a lay of the land when it comes to multithreading techniques on iOS, and how you can use some of them in your app. We didn't get to cover many of the lower-level constructs like locks, mutexes and how they help us achieve synchronization, nor did we get to dive into concrete examples of how concurrency can hurt your app. We'll save those for another day, but you can dig into some additional reading and videos if you're eager to dive deeper. Building Concurrent User Interfaces on iOS (WWDC 2012) Concurrency and Parallelism: Understanding I/O Apple's Official Concurrency Programming Guide Mutexes and Closure Capture in Swift Locks, Thread Safety, and Swift Advanced NSOperations (WWDC 2015) NSHipster: NSOperation Full Article Code
ul Should you use Userbase for your next static site? By feedproxy.google.com Published On :: Wed, 06 May 2020 08:00:00 -0400 During the winter 2020 Pointless Weekend, we built TrailBuddy (working app coming soon). Our team consisted of four developers, two project managers, two front-end developers, a digital-analyst, a UXer, and a designer. In about 48 hours, we took an idea from Jeremy Field’s head to a (mostly) working app. We broke up the project in two parts:. First, a back-end that crunches trail, weather, and soil data. That data is exposed via a GraphQL API for a web app to consume. While developers built the API, I built a static front end using Next.js. Famously, static front-ends don’t have a database, or a concept of “users.” A bit of functionality I wanted to add was saving favorite trails. I didn’t want to be hacky about it, I needed some way to add users and a database. I knew it’d be hard for the developers to set this up as part of the API, they had their hands full with all the #soil-soil-soil-soil-soil (a slack channel dedicated solely to figuring out our soil data problem—those were plentiful.) I had been looking for an excuse to use Userbase, and this seemed like as good a time as any. A textbook Userbase use case “When would I use it?” The Usebase site lists these reasons: If you want to build a web app without writing any backend code. If you never want to see your users' data. If you're tired of dealing with databases. If you want to radically simplify your GDPR compliance. And if you want to keep things really simple. This was a perfect fit for my problem. I didn’t want to write any more backend code for this. I didn’t want to see our user’s data, I don’t care to know anyone’s favorite trails.* A nice bonus to not having users in our backend was not having to worry about keeping their data safe. We don’t have their data at all, it’s end-to-end encrypted by Userbase. We can offer a reasonable amount of privacy for free (well for the price of using Userbase: $49 a year.) I am not tired of dealing with databases, but I’d rather not. I don’t think anyone doesn’t want to simplify their GDPR compliance. Finally, given our tight timeline I wanted nothing more than to keep things really simple. A sign up form that I didn't have to write a back-end for Using Userbase Userbase can be tried for free, so I set aside thirty minutes or so to do a quick proof of concept to make sure this would work out for us. I made an account and followed their Quickstart. Userbase is a fundamentally easy tool to use, but their quickstart is everything I’d want out of a quickstart: Written in the most vanilla way possible (just HTML and vanilla JS). This means I can adapt it to my needs, in this case React using Next.js Easy to follow, it does the most barebones tour of the functionality you can expect to get out of the SDK (software development kit.) In other words it is quick and it is a start It has a live demo and code samples you can download and run yourself It didn’t take long after that to integrate Userbase into our app with more help from their great docs. I debated whether to add code samples of what we did here, and I didn’t because any reader would be better off using the great quickstart and docs Userbase provides—they are that clear, and that good. Depending on your use case you’ll need to adapt the examples to your needs, for us the trickiest things were creating a top level authentication context to manage users in the app, and a custom hook to encapsulate all the logic for setting, updating, and deleting favourite trails in the app. Userbase’s SDK worked seamlessly for us. A log in form that I didn't have to write a back-end for Is Userbase for you? Maybe. I am definitely a fan, so much so that this blog post probably reads like an advert. Userbase saved me a ton of time in this project. It reminded me of “The All Powerful Front End Developer” talk by Chris Coyer. I don’t fully subscribe to all the ideas in that talk, but it is nice to have “serverless” tools like Userbase, and all the new JAMstacky things. There are limits to the Userbase serverless experience in terms of scale, and control. Obviously relying on a third party for something always carries some (probably small) risk—it’s worth noting Usebase includes a note on their pricing page that says “You can host it yourself always under your control, or we can run it for you for a full serverless experience”—Still, I wouldn’t hesitate this to use in future projects. One of the great things about Viget and Pointless Weekend is the opportunity to try new things. For me that was Next.js and Userbase for Trailbuddy. It doesn’t always work out (in fact this is my first pointless weekend where a risk hasn’t blown up in my face) but it is always fun. Getting to try out Userbase and beginning to think about how we may use it in the future made the weekend worthwhile for me, and it made my job on this project much more enjoyable. *I will write a future post about privacy conscious analytics in TrailBuddy when I’ve figured that out. I am looking into Fathom Analytics for that. Full Article Code Front-end Engineering
ul Five Aspects of a Successful Blog Post By feedproxy.google.com Published On :: Tue, 06 Feb 2018 14:34:13 +0000 It’s 2018, and traditional marketing concept has shifted. We often hear that content marketing is taking the top and is the future of marketing. While content marketing doesn’t only mean blogging, blog posts on a product, service or about your business, should be a big part of your content marketing strategy. There are vast amounts … Five Aspects of a Successful Blog Post Read More » Full Article Reference
ul Old and broken – but oh so beautiful By feedproxy.google.com Published On :: Thu, 15 Nov 2018 16:29:09 +0000 For years now I’ve had a thing for old doorways with big old locks – now on Cyprus it escalated a bit due to the number of absolutely beautiful old doors. Many of them not restored but broken or run […] Full Article Photo Trip
ul Why Collaborative Coding Is The Ultimate Career Hack By feedproxy.google.com Published On :: Fri, 24 Apr 2020 10:30:00 +0000 Taking your first steps in programming is like picking up a foreign language. At first, the syntax makes no sense, the vocabulary is unfamiliar, and everything looks and sounds unintelligible. If you’re anything like me when I started, fluency feels impossible. I promise it isn’t. When I began coding, the learning curve hit me — hard. I spent ten months teaching myself the basics while trying to stave off feelings of self-doubt that I now recognize as imposter syndrome. Full Article
ul Readability Algorithms Should Be Tools, Not Targets By feedproxy.google.com Published On :: Fri, 01 May 2020 11:30:00 +0000 The web is awash with words. They’re everywhere. On websites, in emails, advertisements, tweets, pop-ups, you name it. More people are publishing more copy than at any point in history. That means a lot of information, and a lot of competition. In recent years a slew of ‘readability’ programs have appeared to help us tidy up the things we write. (Grammarly, Readable, and Yoast are just a handful that come to mind. Full Article
ul DJI’s new Matrice 300 RTK drone offers a ridiculous 55-minutes of flight time and 2.7kg payload By feedproxy.google.com Published On :: Thu, 07 May 2020 22:27:23 +0000 DJI has announced their new Matrice 300 RTK “flying platform” (big drone) and the Zenmuse H20 hybrid camera series, to provide “a safer and smarter solution” to their enterprise customers. The M300 RTK, DJI says, is their first to integrate modern aviation features, advanced AI, 6-direction sensing and positioning, a UAV health management system and […] The post DJI’s new Matrice 300 RTK drone offers a ridiculous 55-minutes of flight time and 2.7kg payload appeared first on DIY Photography. Full Article DIY dji DJI M300 RTK DJI Matrice 300 RTK Matrice 300 RTK
ul Fulltime Result Picks *** Sunday *** 17 September 2017 By dataviz.tumblr.com Published On :: Sat, 16 Sep 2017 19:44:09 -0400 We have a new preview on https://www.007soccerpicks.com/sunday-matches/fulltime-result-picks-sunday-17-september-2017/Fulltime Result Picks *** Sunday *** 17 September 2017 FULLTIME PICKS To return: ??? USD Odds: 3.88 Stake: 100 USD Starting in Teams Our Prediction Odds Waregem - Mouscron Soccer: Belgium - Jupiler League 1 1.61 Sassuolo - Juventus Soccer: Italy - Serie… Full Article fulltime predictions fulltime tips and picks FULLTIME RESULT Sunday Matches
ul Fulltime Result Picks *** Monday *** 18 September 2017 By dataviz.tumblr.com Published On :: Sun, 17 Sep 2017 19:02:01 -0400 We have a new preview on https://www.007soccerpicks.com/monday-matches/fulltime-result-picks-monday-18-september-2017/Fulltime Result Picks *** Monday *** 18 September 2017 FULLTIME PICKS To return: ??? USD Odds: 3.77 Stake: 100 USD Starting in Teams Our Prediction Odds Plzen - Zlin Soccer: Czech Republic - 1. Liga 1 1.39 Odd - Aalesund Soccer: Norway -… Full Article fulltime predictions fulltime tips and picks FULLTIME RESULT Monday Matches
ul Fulltime Result Picks *** Tuesday *** 19 September 2017 By dataviz.tumblr.com Published On :: Mon, 18 Sep 2017 16:05:34 -0400 We have a new preview on https://www.007soccerpicks.com/tuesday-matches/fulltime-result-picks-tuesday-19-september-2017/Fulltime Result Picks *** Tuesday *** 19 September 2017 FULLTIME PICKS To return: ??? USD Odds: 5.40 Stake: 100 USD Starting in Teams Our Prediction Odds GAIS - Frej Soccer: Sweden - Superettan 1 1.82 Bologna - Inter Soccer: Italy - Serie… Full Article fulltime picks fulltime predictions and tips FULLTIME RESULT Tuesday Matches
ul Regular Tur'an numbers of complete bipartite graphs. (arXiv:2005.02907v2 [math.CO] UPDATED) By arxiv.org Published On :: Let $mathrm{rex}(n, F)$ denote the maximum number of edges in an $n$-vertex graph that is regular and does not contain $F$ as a subgraph. We give lower bounds on $mathrm{rex}(n, F)$, that are best possible up to a constant factor, when $F$ is one of $C_4$, $K_{2,t}$, $K_{3,3}$ or $K_{s,t}$ when $t>s!$. Full Article
ul Some Quot schemes in tilted hearts and moduli spaces of stable pairs. (arXiv:2005.02202v2 [math.AG] UPDATED) By arxiv.org Published On :: For a smooth projective variety $X$, we study analogs of Quot functors in hearts of non-standard $t$-structures of $D^b(mathrm{Coh}(X))$. The technical framework is that of families of $t$-structures, as studied in arXiv:1902.08184. We provide several examples and suggest possible directions of further investigation, as we reinterpret moduli spaces of stable pairs, in the sense of Thaddeus (arXiv:alg-geom/9210007) and Huybrechts-Lehn (arXiv:alg-geom/9211001), as instances of Quot schemes. Full Article
ul Nonlinear singular problems with indefinite potential term. (arXiv:2005.01789v3 [math.AP] UPDATED) By arxiv.org Published On :: We consider a nonlinear Dirichlet problem driven by a nonhomogeneous differential operator plus an indefinite potential. In the reaction we have the competing effects of a singular term and of concave and convex nonlinearities. In this paper the concave term is parametric. We prove a bifurcation-type theorem describing the changes in the set of positive solutions as the positive parameter $lambda$ varies. This work continues our research published in arXiv:2004.12583, where $xi equiv 0 $ and in the reaction the parametric term is the singular one. Full Article
ul Solving an inverse problem for the Sturm-Liouville operator with a singular potential by Yurko's method. (arXiv:2004.14721v2 [math.SP] UPDATED) By arxiv.org Published On :: An inverse spectral problem for the Sturm-Liouville operator with a singular potential from the class $W_2^{-1}$ is solved by the method of spectral mappings. We prove the uniqueness theorem, develop a constructive algorithm for solution, and obtain necessary and sufficient conditions of solvability for the inverse problem in the self-adjoint and the non-self-adjoint cases Full Article
ul On the exterior Dirichlet problem for a class of fully nonlinear elliptic equations. (arXiv:2004.12660v3 [math.AP] UPDATED) By arxiv.org Published On :: In this paper, we mainly establish the existence and uniqueness theorem for solutions of the exterior Dirichlet problem for a class of fully nonlinear second-order elliptic equations related to the eigenvalues of the Hessian, with prescribed generalized symmetric asymptotic behavior at infinity. Moreover, we give some new results for the Hessian equations, Hessian quotient equations and the special Lagrangian equations, which have been studied previously. Full Article
ul Finite dimensional simple modules of $(q, mathbf{Q})$-current algebras. (arXiv:2004.11069v2 [math.RT] UPDATED) By arxiv.org Published On :: The $(q, mathbf{Q})$-current algebra associated with the general linear Lie algebra was introduced by the second author in the study of representation theory of cyclotomic $q$-Schur algebras. In this paper, we study the $(q, mathbf{Q})$-current algebra $U_q(mathfrak{sl}_n^{langle mathbf{Q} angle}[x])$ associated with the special linear Lie algebra $mathfrak{sl}_n$. In particular, we classify finite dimensional simple $U_q(mathfrak{sl}_n^{langle mathbf{Q} angle}[x])$-modules. Full Article
ul $L^p$-regularity of the Bergman projection on quotient domains. (arXiv:2004.02598v2 [math.CV] UPDATED) By arxiv.org Published On :: We relate the $L^p$-mapping properties of the Bergman projections on two domains in $mathbb{C}^n$, one of which is the quotient of the other under the action of a finite group of biholomorphic automorphisms. We use this relation to deduce the sharp ranges of $L^p$-boundedness of the Bergman projection on certain $n$-dimensional model domains generalizing the Hartogs triangle. Full Article
ul Willems' Fundamental Lemma for State-space Systems and its Extension to Multiple Datasets. (arXiv:2002.01023v2 [math.OC] UPDATED) By arxiv.org Published On :: Willems et al.'s fundamental lemma asserts that all trajectories of a linear system can be obtained from a single given one, assuming that a persistency of excitation condition holds. This result has profound implications for system identification and data-driven control, and has seen a revival over the last few years. The purpose of this paper is to extend Willems' lemma to the situation where multiple (possibly short) system trajectories are given instead of a single long one. To this end, we introduce a notion of collective persistency of excitation. We will then show that all trajectories of a linear system can be obtained from a given finite number of trajectories, as long as these are collectively persistently exciting. We will demonstrate that this result enables the identification of linear systems from data sets with missing data samples. Additionally, we show that the result is of practical significance in data-driven control of unstable systems. Full Article
ul Stationary Gaussian Free Fields Coupled with Stochastic Log-Gases via Multiple SLEs. (arXiv:2001.03079v3 [math.PR] UPDATED) By arxiv.org Published On :: Miller and Sheffield introduced a notion of an imaginary surface as an equivalence class of pairs of simply connected proper subdomains of $mathbb{C}$ and Gaussian free fields (GFFs) on them under conformal equivalence. They considered the situation in which the conformal transformations are given by a chordal Schramm--Loewner evolution (SLE). In the present paper, we construct processes of GFF on $mathbb{H}$ (the upper half-plane) and $mathbb{O}$ (the first orthant of $mathbb{C}$) by coupling zero-boundary GFFs on these domains with stochastic log-gases defined on parts of boundaries of the domains, $mathbb{R}$ and $mathbb{R}_+$, called the Dyson model and the Bru--Wishart process, respectively, using multiple SLEs evolving in time. We prove that the obtained processes of GFF are stationary. The stationarity defines an equivalence relation between GFFs, and the pairs of time-evolutionary domains and stationary processes of GFF will be regarded as generalizations of the imaginary surfaces studied by Miller and Sheffield. Full Article
ul Regularized vortex approximation for 2D Euler equations with transport noise. (arXiv:1912.07233v2 [math.PR] UPDATED) By arxiv.org Published On :: We study a mean field approximation for the 2D Euler vorticity equation driven by a transport noise. We prove that the Euler equations can be approximated by interacting point vortices driven by a regularized Biot-Savart kernel and the same common noise. The approximation happens by sending the number of particles $N$ to infinity and the regularization $epsilon$ in the Biot-Savart kernel to $0$, as a suitable function of $N$. Full Article
ul On boundedness, gradient estimate, blow-up and convergence in a two-species and two-stimuli chemotaxis system with/without loop. (arXiv:1909.04587v4 [math.AP] UPDATED) By arxiv.org Published On :: In this work, we study dynamic properties of classical solutions to a homogenous Neumann initial-boundary value problem (IBVP) for a two-species and two-stimuli chemotaxis model with/without chemical signalling loop in a 2D bounded and smooth domain. We successfully detect the product of two species masses as a feature to determine boundedness, gradient estimates, blow-up and $W^{j,infty}(1leq jleq 3)$-exponential convergence of classical solutions for the corresponding IBVP. More specifically, we first show generally a smallness on the product of both species masses, thus allowing one species mass to be suitably large, is sufficient to guarantee global boundedness, higher order gradient estimates and $W^{j,infty}$-convergence with rates of convergence to constant equilibria; and then, in a special case, we detect a straight line of masses on which blow-up occurs for large product of masses. Our findings provide new understandings about the underlying model, and thus, improve and extend greatly the existing knowledge relevant to this model. Full Article
ul Multitype branching process with nonhomogeneous Poisson and generalized Polya immigration. (arXiv:1909.03684v2 [math.PR] UPDATED) By arxiv.org Published On :: In a multitype branching process, it is assumed that immigrants arrive according to a nonhomogeneous Poisson or a generalized Polya process (both processes are formulated as a nonhomogeneous birth process with an appropriate choice of transition intensities). We show that the renormalized numbers of objects of the various types alive at time $t$ for supercritical, critical, and subcritical cases jointly converge in distribution under those two different arrival processes. Furthermore, some transient moment analysis when there are only two types of particles is provided. AMS 2000 subject classifications: Primary 60J80, 60J85; secondary 60K10, 60K25, 90B15. Full Article
ul Integrability of moduli and regularity of Denjoy counterexamples. (arXiv:1908.06568v4 [math.DS] UPDATED) By arxiv.org Published On :: We study the regularity of exceptional actions of groups by $C^{1,alpha}$ diffeomorphisms on the circle, i.e. ones which admit exceptional minimal sets, and whose elements have first derivatives that are continuous with concave modulus of continuity $alpha$. Let $G$ be a finitely generated group admitting a $C^{1,alpha}$ action $ ho$ with a free orbit on the circle, and such that the logarithms of derivatives of group elements are uniformly bounded at some point of the circle. We prove that if $G$ has spherical growth bounded by $c n^{d-1}$ and if the function $1/alpha^d$ is integrable near zero, then under some mild technical assumptions on $alpha$, there is a sequence of exceptional $C^{1,alpha}$ actions of $G$ which converge to $ ho$ in the $C^1$ topology. As a consequence for a single diffeomorphism, we obtain that if the function $1/alpha$ is integrable near zero, then there exists a $C^{1,alpha}$ exceptional diffeomorphism of the circle. This corollary accounts for all previously known moduli of continuity for derivatives of exceptional diffeomorphisms. We also obtain a partial converse to our main result. For finitely generated free abelian groups, the existence of an exceptional action, together with some natural hypotheses on the derivatives of group elements, puts integrability restrictions on the modulus $alpha$. These results are related to a long-standing question of D. McDuff concerning the length spectrum of exceptional $C^1$ diffeomorphisms of the circle. Full Article
ul Diophantine Equations Involving the Euler Totient Function. (arXiv:1902.01638v4 [math.NT] UPDATED) By arxiv.org Published On :: We deal with various Diophantine equations involving the Euler totient function and various sequences of numbers, including factorials, powers, and Fibonacci sequences. Full Article
ul Bernoulli decomposition and arithmetical independence between sequences. (arXiv:1811.11545v2 [math.NT] UPDATED) By arxiv.org Published On :: In this paper we study the following set[A={p(n)+2^nd mod 1: ngeq 1}subset [0.1],] where $p$ is a polynomial with at least one irrational coefficient on non constant terms, $d$ is any real number and for $ain [0,infty)$, $a mod 1$ is the fractional part of $a$. By a Bernoulli decomposition method, we show that the closure of $A$ must have full Hausdorff dimension. Full Article
ul On the rationality of cycle integrals of meromorphic modular forms. (arXiv:1810.00612v3 [math.NT] UPDATED) By arxiv.org Published On :: We derive finite rational formulas for the traces of cycle integrals of certain meromorphic modular forms. Moreover, we prove the modularity of a completion of the generating function of such traces. The theoretical framework for these results is an extension of the Shintani theta lift to meromorphic modular forms of positive even weight. Full Article
ul Expansion of Iterated Stratonovich Stochastic Integrals of Arbitrary Multiplicity Based on Generalized Iterated Fourier Series Converging Pointwise. (arXiv:1801.00784v9 [math.PR] UPDATED) By arxiv.org Published On :: The article is devoted to the expansion of iterated Stratonovich stochastic integrals of arbitrary multiplicity $k$ $(kinmathbb{N})$ based on the generalized iterated Fourier series. The case of Fourier-Legendre series as well as the case of trigonotemric Fourier series are considered in details. The obtained expansion provides a possibility to represent the iterated Stratonovich stochastic integral in the form of iterated series of products of standard Gaussian random variables. Convergence in the mean of degree $2n$ $(nin mathbb{N})$ of the expansion is proved. Some modifications of the mentioned expansion were derived for the case $k=2$. One of them is based of multiple trigonomentric Fourier series converging almost everywhere in the square $[t, T]^2$. The results of the article can be applied to the numerical solution of Ito stochastic differential equations. Full Article
ul Local Moduli of Semisimple Frobenius Coalescent Structures. (arXiv:1712.08575v3 [math.DG] UPDATED) By arxiv.org Published On :: We extend the analytic theory of Frobenius manifolds to semisimple points with coalescing eigenvalues of the operator of multiplication by the Euler vector field. We clarify which freedoms, ambiguities and mutual constraints are allowed in the definition of monodromy data, in view of their importance for conjectural relationships between Frobenius manifolds and derived categories. Detailed examples and applications are taken from singularity and quantum cohomology theories. We explicitly compute the monodromy data at points of the Maxwell Stratum of the A3-Frobenius manifold, as well as at the small quantum cohomology of the Grassmannian G(2,4). In the latter case, we analyse in details the action of the braid group on the monodromy data. This proves that these data can be expressed in terms of characteristic classes of mutations of Kapranov's exceptional 5-block collection, as conjectured by one of the authors. Full Article
ul Simulation of Integro-Differential Equation and Application in Estimation of Ruin Probability with Mixed Fractional Brownian Motion. (arXiv:1709.03418v6 [math.PR] UPDATED) By arxiv.org Published On :: In this paper, we are concerned with the numerical solution of one type integro-differential equation by a probability method based on the fundamental martingale of mixed Gaussian processes. As an application, we will try to simulate the estimation of ruin probability with an unknown parameter driven not by the classical L'evy process but by the mixed fractional Brownian motion. Full Article
ul Categorification via blocks of modular representations for sl(n). (arXiv:1612.06941v3 [math.RT] UPDATED) By arxiv.org Published On :: Bernstein, Frenkel, and Khovanov have constructed a categorification of tensor products of the standard representation of $mathfrak{sl}_2$, where they use singular blocks of category $mathcal{O}$ for $mathfrak{sl}_n$ and translation functors. Here we construct a positive characteristic analogue using blocks of representations of $mathfrak{sl}_n$ over a field $ extbf{k}$ of characteristic $p$ with zero Frobenius character, and singular Harish-Chandra character. We show that the aforementioned categorification admits a Koszul graded lift, which is equivalent to a geometric categorification constructed by Cautis, Kamnitzer, and Licata using coherent sheaves on cotangent bundles to Grassmanians. In particular, the latter admits an abelian refinement. With respect to this abelian refinement, the stratified Mukai flop induces a perverse equivalence on the derived categories for complementary Grassmanians. This is part of a larger project to give a combinatorial approach to Lusztig's conjectures for representations of Lie algebras in positive characteristic. Full Article
ul A Hamilton-Jacobi Formulation for Time-Optimal Paths of Rectangular Nonholonomic Vehicles. (arXiv:2005.03623v1 [math.OC]) By arxiv.org Published On :: We address the problem of optimal path planning for a simple nonholonomic vehicle in the presence of obstacles. Most current approaches are either split hierarchically into global path planning and local collision avoidance, or neglect some of the ambient geometry by assuming the car is a point mass. We present a Hamilton-Jacobi formulation of the problem that resolves time-optimal paths and considers the geometry of the vehicle. Full Article
ul Positive Geometries and Differential Forms with Non-Logarithmic Singularities I. (arXiv:2005.03612v1 [hep-th]) By arxiv.org Published On :: Positive geometries encode the physics of scattering amplitudes in flat space-time and the wavefunction of the universe in cosmology for a large class of models. Their unique canonical forms, providing such quantum mechanical observables, are characterised by having only logarithmic singularities along all the boundaries of the positive geometry. However, physical observables have logarithmic singularities just for a subset of theories. Thus, it becomes crucial to understand whether a similar paradigm can underlie their structure in more general cases. In this paper we start a systematic investigation of a geometric-combinatorial characterisation of differential forms with non-logarithmic singularities, focusing on projective polytopes and related meromorphic forms with multiple poles. We introduce the notions of covariant forms and covariant pairings. Covariant forms have poles only along the boundaries of the given polytope; moreover, their leading Laurent coefficients along any of the boundaries are still covariant forms on the specific boundary. Whereas meromorphic forms in covariant pairing with a polytope are associated to a specific (signed) triangulation, in which poles on spurious boundaries do not cancel completely, but their order is lowered. These meromorphic forms can be fully characterised if the polytope they are associated to is viewed as the restriction of a higher dimensional one onto a hyperplane. The canonical form of the latter can be mapped into a covariant form or a form in covariant pairing via a covariant restriction. We show how the geometry of the higher dimensional polytope determines the structure of these differential forms. Finally, we discuss how these notions are related to Jeffrey-Kirwan residues and cosmological polytopes. Full Article
ul Groups up to congruence relation and from categorical groups to c-crossed modules. (arXiv:2005.03601v1 [math.CT]) By arxiv.org Published On :: We introduce a notion of c-group, which is a group up to congruence relation and consider the corresponding category. Extensions, actions and crossed modules (c-crossed modules) are defined in this category and the semi-direct product is constructed. We prove that each categorical group gives rise to c-groups and to a c-crossed module, which is a connected, special and strict c-crossed module in the sense defined by us. The results obtained here will be applied in the proof of an equivalence of the categories of categorical groups and connected, special and strict c-crossed modules. Full Article
ul Minimal acceleration for the multi-dimensional isentropic Euler equations. (arXiv:2005.03570v1 [math.AP]) By arxiv.org Published On :: Among all dissipative solutions of the multi-dimensional isentropic Euler equations there exists at least one that minimizes the acceleration, which implies that the solution is as close to being a weak solution as possible. The argument is based on a suitable selection procedure. Full Article
ul Toric Sasaki-Einstein metrics with conical singularities. (arXiv:2005.03502v1 [math.DG]) By arxiv.org Published On :: We show that any toric K"ahler cone with smooth compact cross-section admits a family of Calabi-Yau cone metrics with conical singularities along its toric divisors. The family is parametrized by the Reeb cone and the angles are given explicitly in terms of the Reeb vector field. The result is optimal, in the sense that any toric Calabi-Yau cone metric with conical singularities along the toric divisor (and smooth elsewhere) belongs to this family. We also provide examples and interpret our results in terms of Sasaki-Einstein metrics. Full Article
ul On completion of unimodular rows over polynomial extension of finitely generated rings over $mathbb{Z}$. (arXiv:2005.03485v1 [math.AC]) By arxiv.org Published On :: In this article, we prove that if $R$ is a finitely generated ring over $mathbb{Z}$ of dimension $d, dgeq2, frac{1}{d!}in R$, then any unimodular row over $R[X]$ of length $d+1$ can be mapped to a factorial row by elementary transformations. Full Article
ul Characteristic Points, Fundamental Cubic Form and Euler Characteristic of Projective Surfaces. (arXiv:2005.03481v1 [math.DG]) By arxiv.org Published On :: We define local indices for projective umbilics and godrons (also called cusps of Gauss) on generic smooth surfaces in projective 3-space. By means of these indices, we provide formulas that relate the algebraic numbers of those characteristic points on a surface (and on domains of the surface) with the Euler characteristic of that surface (resp. of those domains). These relations determine the possible coexistences of projective umbilics and godrons on the surface. Our study is based on a "fundamental cubic form" for which we provide a closed simple expression. Full Article
ul Aspiration can promote cooperation in well-mixed populations as in regular graphs. (arXiv:2005.03421v1 [q-bio.PE]) By arxiv.org Published On :: Classical studies on aspiration-based dynamics suggest that a dissatisfied individual changes strategy without taking into account the success of others. This promotes defection spreading. The imitation-based dynamics allow individuals to imitate successful strategies without taking into account their own-satisfactions. In this article, we propose to study a dynamic based on aspiration which takes into account imitation of successful strategies for dissatisfied individuals. This helps cooperative members to resist. Individuals compare their success to their desired satisfaction level before making a decision to update their strategies. This mechanism helps individuals with a minimum of self-satisfaction to maintain their strategies. If an individual is dissatisfied, it will learn from others by choosing successful strategies. We derive an exact expression of the fixation probability in well-mixed populations as in structured populations in networks. As a result, we show that selection may favor cooperation more than defection in well-mixed populations as in populations ranged over a regular graph. We show that the best scenario is a graph with small connectivity. Full Article
ul Removable singularities for Lipschitz caloric functions in time varying domains. (arXiv:2005.03397v1 [math.CA]) By arxiv.org Published On :: In this paper we study removable singularities for regular $(1,1/2)$-Lipschitz solutions of the heat equation in time varying domains. We introduce an associated Lipschitz caloric capacity and we study its metric and geometric properties and the connection with the $L^2$ boundedness of the singular integral whose kernel is given by the gradient of the fundamental solution of the heat equation. Full Article
ul Semiglobal non-oscillatory big bang singular spacetimes for the Einstein-scalar field system. (arXiv:2005.03395v1 [math-ph]) By arxiv.org Published On :: We construct semiglobal singular spacetimes for the Einstein equations coupled to a massless scalar field. Consistent with the heuristic analysis of Belinskii, Khalatnikov, Lifshitz or BKL for this system, there are no oscillations due to the scalar field. (This is much simpler than the oscillatory BKL heuristics for the Einstein vacuum equations.) Prior results are due to Andersson and Rendall in the real analytic case, and Rodnianski and Speck in the smooth near-spatially-flat-FLRW case. Similar to Andersson and Rendall we give asymptotic data at the singularity, which we refer to as final data, but our construction is not limited to real analytic solutions. This paper is a test application of tools (a graded Lie algebra formulation of the Einstein equations and a filtration) intended for the more subtle vacuum case. We use homological algebra tools to construct a formal series solution, then symmetric hyperbolic energy estimates to construct a true solution well-approximated by truncations of the formal one. We conjecture that the image of the map from final data to initial data is an open set of anisotropic initial data. Full Article
ul A theory of stacks with twisted fields and resolution of moduli of genus two stable maps. (arXiv:2005.03384v1 [math.AG]) By arxiv.org Published On :: We construct a smooth moduli stack of tuples consisting of genus two nodal curves, line bundles, and twisted fields. It leads to a desingularization of the moduli of genus two stable maps to projective spaces. The construction of this new moduli is based on systematical application of the theory of stacks with twisted fields (STF), which has its prototype appeared in arXiv:1906.10527 and arXiv:1201.2427 and is fully developed in this article. The results of this article are the second step of a series of works toward the resolutions of the moduli of stable maps of higher genera. Full Article
ul A regularity criterion of the 3D MHD equations involving one velocity and one current density component in Lorentz. (arXiv:2005.03377v1 [math.AP]) By arxiv.org Published On :: In this paper, we study the regularity criterion of weak solutions to the three-dimensional (3D) MHD equations. It is proved that the solution $(u,b)$ becomes regular provided that one velocity and one current density component of the solution satisfy% egin{equation} u_{3}in L^{frac{30alpha }{7alpha -45}}left( 0,T;L^{alpha ,infty }left( mathbb{R}^{3} ight) ight) ext{ with }frac{45}{7}% leq alpha leq infty , label{eq01} end{equation}% and egin{equation} j_{3}in L^{frac{2eta }{2eta -3}}left( 0,T;L^{eta ,infty }left( mathbb{R}^{3} ight) ight) ext{ with }frac{3}{2}leq eta leq infty , label{eq02} end{equation}% which generalize some known results. Full Article
ul Asymptotics of PDE in random environment by paracontrolled calculus. (arXiv:2005.03326v1 [math.PR]) By arxiv.org Published On :: We apply the paracontrolled calculus to study the asymptotic behavior of a certain quasilinear PDE with smeared mild noise, which originally appears as the space-time scaling limit of a particle system in random environment on one dimensional discrete lattice. We establish the convergence result and show a local in time well-posedness of the limit stochastic PDE with spatial white noise. It turns out that our limit stochastic PDE does not require any renormalization. We also show a comparison theorem for the limit equation. Full Article
ul Riemann-Hilbert approach and N-soliton formula for the N-component Fokas-Lenells equations. (arXiv:2005.03319v1 [nlin.SI]) By arxiv.org Published On :: In this work, the generalized $N$-component Fokas-Lenells(FL) equations, which have been studied by Guo and Ling (2012 J. Math. Phys. 53 (7) 073506) for $N=2$, are first investigated via Riemann-Hilbert(RH) approach. The main purpose of this is to study the soliton solutions of the coupled Fokas-Lenells(FL) equations for any positive integer $N$, which have more complex linear relationship than the analogues reported before. We first analyze the spectral analysis of the Lax pair associated with a $(N+1) imes (N+1)$ matrix spectral problem for the $N$-component FL equations. Then, a kind of RH problem is successfully formulated. By introducing the special conditions of irregularity and reflectionless case, the $N$-soliton solution formula of the equations are derived through solving the corresponding RH problem. Furthermore, take $N=2,3$ and $4$ for examples, the localized structures and dynamic propagation behavior of their soliton solutions and their interactions are discussed by some graphical analysis. Full Article
ul New constructions of strongly regular Cayley graphs on abelian groups. (arXiv:2005.03183v1 [math.CO]) By arxiv.org Published On :: In this paper, we give new constructions of strongly regular Cayley graphs on abelian groups as generalizations of a series of known constructions: the construction of covering extended building sets in finite fields by Xia (1992), the product construction of Menon-Hadamard difference sets by Turyn (1984), and the construction of Paley type partial difference sets by Polhill (2010). Then, we obtain new large families of strongly regular Cayley graphs of Latin square type or negative Latin square type. Full Article
ul Solid hulls and cores of classes of weighted entire functions defined in terms of associated weight functions. (arXiv:2005.03167v1 [math.FA]) By arxiv.org Published On :: In the spirit of very recent articles by J. Bonet, W. Lusky and J. Taskinen we are studying the so-called solid hulls and cores of spaces of weighted entire functions when the weights are given in terms of associated weight functions coming from weight sequences. These sequences are required to satisfy certain (standard) growth and regularity properties which are frequently arising and used in the theory of ultradifferentiable and ultraholomorphic function classes (where also the associated weight function plays a prominent role). Thanks to this additional information we are able to see which growth behavior the so-called "Lusky-numbers", arising in the representations of the solid hulls and cores, have to satisfy resp. if such numbers can exist. Full Article
ul Homotopy invariance of the space of metrics with positive scalar curvature on manifolds with singularities. (arXiv:2005.03073v1 [math.AT]) By arxiv.org Published On :: In this paper we study manifolds $M_{Sigma}$ with fibered singularities, more specifically, a relevant space $Riem^{psc}(X_{Sigma})$ of Riemannian metrics with positive scalar curvature. Our main goal is to prove that the space $Riem^{psc}(X_{Sigma})$ is homotopy invariant under certain surgeries on $M_{Sigma}$. Full Article
ul Multi-Resolution POMDP Planning for Multi-Object Search in 3D. (arXiv:2005.02878v2 [cs.RO] UPDATED) By arxiv.org Published On :: Robots operating in household environments must find objects on shelves, under tables, and in cupboards. Previous work often formulate the object search problem as a POMDP (Partially Observable Markov Decision Process), yet constrain the search space in 2D. We propose a new approach that enables the robot to efficiently search for objects in 3D, taking occlusions into account. We model the problem as an object-oriented POMDP, where the robot receives a volumetric observation from a viewing frustum and must produce a policy to efficiently search for objects. To address the challenge of large state and observation spaces, we first propose a per-voxel observation model which drastically reduces the observation size necessary for planning. Then, we present a novel octree-based belief representation which captures beliefs at different resolutions and supports efficient exact belief update. Finally, we design an online multi-resolution planning algorithm that leverages the resolution layers in the octree structure as levels of abstractions to the original POMDP problem. Our evaluation in a simulated 3D domain shows that, as the problem scales, our approach significantly outperforms baselines without resolution hierarchy by 25%-35% in cumulative reward. We demonstrate the practicality of our approach on a torso-actuated mobile robot searching for objects in areas of a cluttered lab environment where objects appear on surfaces at different heights. Full Article
